Add schemes (#71)

* Move br + cbt to schemes/tfhe * refactor blind rotation * refactor circuit bootstrapping * renamed exec -> prepared
2026-02-10 13:16:44 +01:00 · 2025-08-15 15:06:26 +02:00
parent 8d9897b88b
commit c7219c35e9
130 changed files with 2631 additions and 3270 deletions
--- a/core/src/encryption/compressed/gglwe_atk.rs
+++ b/core/src/encryption/compressed/gglwe_atk.rs
@@ -8,19 +8,19 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecret, TakeGLWESecretExec,
+    TakeGLWESecret, TakeGLWESecretPrepared,
    layouts::{
        GLWESecret, Infos,
        compressed::{GGLWEAutomorphismKeyCompressed, GGLWESwitchingKeyCompressed},
    },
 };

-use crate::trait_families::{GGLWEAutomorphismKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWEAutomorphismKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl GGLWEAutomorphismKeyCompressed<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
    where
-        Module<B>: GGLWEAutomorphismKeyEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWEAutomorphismKeyEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
        GGLWESwitchingKeyCompressed::encrypt_sk_scratch_space(module, n, basek, k, rank, rank) + GLWESecret::bytes_of(n, rank)
    }
@@ -41,8 +41,8 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKeyCompressed<DataSelf> {
            + VecZnxSwithcDegree
            + VecZnxAutomorphism
            + VecZnxAddScalarInplace
-            + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretExec<B> + TakeVecZnx,
+            + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretPrepared<B> + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {
--- a/core/src/encryption/compressed/gglwe_ct.rs
+++ b/core/src/encryption/compressed/gglwe_ct.rs
@@ -7,7 +7,7 @@ use sampling::source::Source;
 use crate::{
    TakeGLWEPt,
    encryption::glwe_encrypt_sk_internal,
-    layouts::{GGLWECiphertext, Infos, compressed::GGLWECiphertextCompressed, prepared::GLWESecretExec},
+    layouts::{GGLWECiphertext, Infos, compressed::GGLWECiphertextCompressed, prepared::GLWESecretPrepared},
 };

 use crate::trait_families::{GGLWEEncryptSkFamily, GGLWESwitchingKeyEncryptSkFamily};
@@ -26,7 +26,7 @@ impl<D: DataMut> GGLWECiphertextCompressed<D> {
        &mut self,
        module: &Module<B>,
        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        seed: [u8; 32],
        source_xe: &mut Source,
        sigma: f64,
--- a/core/src/encryption/compressed/gglwe_ksk.rs
+++ b/core/src/encryption/compressed/gglwe_ksk.rs
@@ -5,13 +5,14 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecretExec,
+    TakeGLWESecretPrepared,
    layouts::{
-        GGLWECiphertext, GLWESecret, GGLWESwitchingKey, Infos, compressed::GGLWESwitchingKeyCompressed, prepared::GLWESecretExec,
+        GGLWECiphertext, GGLWESwitchingKey, GLWESecret, Infos, compressed::GGLWESwitchingKeyCompressed,
+        prepared::GLWESecretPrepared,
    },
 };

-use crate::trait_families::{GGLWESwitchingKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWESwitchingKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl GGLWESwitchingKeyCompressed<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(
@@ -23,11 +24,11 @@ impl GGLWESwitchingKeyCompressed<Vec<u8>> {
        rank_out: usize,
    ) -> usize
    where
-        Module<B>: GGLWESwitchingKeyEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWESwitchingKeyEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
        (GGLWECiphertext::encrypt_sk_scratch_space(module, n, basek, k) | ScalarZnx::alloc_bytes(n, 1))
            + ScalarZnx::alloc_bytes(n, rank_in)
-            + GLWESecretExec::bytes_of(module, n, rank_out)
+            + GLWESecretPrepared::bytes_of(module, n, rank_out)
    }
 }

@@ -43,8 +44,9 @@ impl<DataSelf: DataMut> GGLWESwitchingKeyCompressed<DataSelf> {
        scratch: &mut Scratch<B>,
    ) where
        Module<B>:
-            GGLWESwitchingKeyEncryptSkFamily<B> + VecZnxSwithcDegree + VecZnxAddScalarInplace + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretExec<B> + ScratchAvailable + TakeVecZnx,
+            GGLWESwitchingKeyEncryptSkFamily<B> + VecZnxSwithcDegree + VecZnxAddScalarInplace + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>:
+            ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretPrepared<B> + ScratchAvailable + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {
@@ -85,7 +87,7 @@ impl<DataSelf: DataMut> GGLWESwitchingKeyCompressed<DataSelf> {
            );
        });

-        let (mut sk_out_tmp, scratch2) = scratch1.take_glwe_secret_exec(n, sk_out.rank());
+        let (mut sk_out_tmp, scratch2) = scratch1.take_glwe_secret_prepared(n, sk_out.rank());
        {
            let (mut tmp, _) = scratch2.take_scalar_znx(n, 1);
            (0..sk_out.rank()).for_each(|i| {
--- a/core/src/encryption/compressed/gglwe_tsk.rs
+++ b/core/src/encryption/compressed/gglwe_tsk.rs
@@ -8,17 +8,17 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecret, TakeGLWESecretExec,
-    layouts::{GGLWETensorKey, GLWESecret, Infos, compressed::GGLWETensorKeyCompressed},
+    TakeGLWESecret, TakeGLWESecretPrepared,
+    layouts::{GGLWETensorKey, GLWESecret, Infos, compressed::GGLWETensorKeyCompressed, prepared::Prepare},
    trait_families::GLWEDecryptFamily,
 };

-use crate::trait_families::{GGLWETensorKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWETensorKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl GGLWETensorKeyCompressed<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
    where
-        Module<B>: GGLWETensorKeyEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWETensorKeyEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
        GGLWETensorKey::encrypt_sk_scratch_space(module, n, basek, k, rank)
    }
@@ -34,8 +34,10 @@ impl<DataSelf: DataMut> GGLWETensorKeyCompressed<DataSelf> {
        sigma: f64,
        scratch: &mut Scratch<B>,
    ) where
-        Module<B>: GGLWETensorKeyEncryptSkFamily<B> + VecZnxSwithcDegree + VecZnxAddScalarInplace + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeGLWESecretExec<B> + TakeScalarZnx + TakeVecZnx,
+        Module<B>:
+            GGLWETensorKeyEncryptSkFamily<B> + VecZnxSwithcDegree + VecZnxAddScalarInplace + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>:
+            ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeGLWESecretPrepared<B> + TakeScalarZnx + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {
@@ -46,8 +48,8 @@ impl<DataSelf: DataMut> GGLWETensorKeyCompressed<DataSelf> {
        let n: usize = sk.n();
        let rank: usize = self.rank();

-        let (mut sk_dft_prep, scratch1) = scratch.take_glwe_secret_exec(n, rank);
-        sk_dft_prep.prepare(module, &sk);
+        let (mut sk_dft_prep, scratch1) = scratch.take_glwe_secret_prepared(n, rank);
+        sk_dft_prep.prepare(module, &sk, scratch1);

        let (mut sk_dft, scratch2) = scratch1.take_vec_znx_dft(n, rank, 1);

--- a/core/src/encryption/compressed/ggsw_ct.rs
+++ b/core/src/encryption/compressed/ggsw_ct.rs
@@ -7,7 +7,7 @@ use sampling::source::Source;
 use crate::{
    TakeGLWEPt,
    encryption::glwe_encrypt_sk_internal,
-    layouts::{GGSWCiphertext, Infos, compressed::GGSWCiphertextCompressed, prepared::GLWESecretExec},
+    layouts::{GGSWCiphertext, Infos, compressed::GGSWCiphertextCompressed, prepared::GLWESecretPrepared},
 };

 use crate::trait_families::GGSWEncryptSkFamily;
@@ -26,7 +26,7 @@ impl<DataSelf: DataMut> GGSWCiphertextCompressed<DataSelf> {
        &mut self,
        module: &Module<B>,
        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
        sigma: f64,
--- a/core/src/encryption/compressed/glwe_ct.rs
+++ b/core/src/encryption/compressed/glwe_ct.rs
@@ -6,7 +6,7 @@ use sampling::source::Source;

 use crate::{
    encryption::glwe_ct::glwe_encrypt_sk_internal,
-    layouts::{GLWECiphertext, GLWEPlaintext, Infos, compressed::GLWECiphertextCompressed, prepared::GLWESecretExec},
+    layouts::{GLWECiphertext, GLWEPlaintext, Infos, compressed::GLWECiphertextCompressed, prepared::GLWESecretPrepared},
 };

 use crate::trait_families::GLWEEncryptSkFamily;
@@ -25,7 +25,7 @@ impl<D: DataMut> GLWECiphertextCompressed<D> {
        &mut self,
        module: &Module<B>,
        pt: &GLWEPlaintext<DataPt>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
        sigma: f64,
@@ -49,7 +49,7 @@ impl<D: DataMut> GLWECiphertextCompressed<D> {
        &mut self,
        module: &Module<B>,
        pt: Option<(&GLWEPlaintext<DataPt>, usize)>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
        sigma: f64,
--- a/core/src/encryption/gglwe_atk.rs
+++ b/core/src/encryption/gglwe_atk.rs
@@ -8,16 +8,16 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecret, TakeGLWESecretExec,
-    layouts::{GGLWEAutomorphismKey, GLWESecret, GGLWESwitchingKey, Infos},
+    TakeGLWESecret, TakeGLWESecretPrepared,
+    layouts::{GGLWEAutomorphismKey, GGLWESwitchingKey, GLWESecret, Infos},
 };

-use crate::trait_families::{GGLWEAutomorphismKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWEAutomorphismKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl GGLWEAutomorphismKey<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
    where
-        Module<B>: GGLWEAutomorphismKeyEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWEAutomorphismKeyEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
        GGLWESwitchingKey::encrypt_sk_scratch_space(module, n, basek, k, rank, rank) + GLWESecret::bytes_of(n, rank)
    }
@@ -42,8 +42,8 @@ impl<DataSelf: DataMut> GGLWEAutomorphismKey<DataSelf> {
            + VecZnxAutomorphism
            + VecZnxSwithcDegree
            + VecZnxAddScalarInplace
-            + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretExec<B> + TakeVecZnx,
+            + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretPrepared<B> + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {
--- a/core/src/encryption/gglwe_ct.rs
+++ b/core/src/encryption/gglwe_ct.rs
@@ -9,7 +9,7 @@ use sampling::source::Source;

 use crate::{
    TakeGLWEPt,
-    layouts::{GGLWECiphertext, GLWECiphertext, GLWEPlaintext, Infos, prepared::GLWESecretExec},
+    layouts::{GGLWECiphertext, GLWECiphertext, GLWEPlaintext, Infos, prepared::GLWESecretPrepared},
 };

 use crate::trait_families::GGLWEEncryptSkFamily;
@@ -33,7 +33,7 @@ impl<DataSelf: DataMut> GGLWECiphertext<DataSelf> {
        &mut self,
        module: &Module<B>,
        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        source_xa: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
--- a/core/src/encryption/gglwe_ksk.rs
+++ b/core/src/encryption/gglwe_ksk.rs
@@ -5,11 +5,11 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecretExec,
-    layouts::{GGLWECiphertext, GLWESecret, GGLWESwitchingKey, Infos, prepared::GLWESecretExec},
+    TakeGLWESecretPrepared,
+    layouts::{GGLWECiphertext, GGLWESwitchingKey, GLWESecret, Infos, prepared::GLWESecretPrepared},
 };

-use crate::trait_families::{GGLWESwitchingKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWESwitchingKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl GGLWESwitchingKey<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(
@@ -21,11 +21,11 @@ impl GGLWESwitchingKey<Vec<u8>> {
        rank_out: usize,
    ) -> usize
    where
-        Module<B>: GGLWESwitchingKeyEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWESwitchingKeyEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
        (GGLWECiphertext::encrypt_sk_scratch_space(module, n, basek, k) | ScalarZnx::alloc_bytes(n, 1))
            + ScalarZnx::alloc_bytes(n, rank_in)
-            + GLWESecretExec::bytes_of(module, n, rank_out)
+            + GLWESecretPrepared::bytes_of(module, n, rank_out)
    }

    pub fn encrypt_pk_scratch_space<B: Backend>(
@@ -52,8 +52,9 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
        scratch: &mut Scratch<B>,
    ) where
        Module<B>:
-            GGLWESwitchingKeyEncryptSkFamily<B> + VecZnxSwithcDegree + VecZnxAddScalarInplace + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretExec<B> + ScratchAvailable + TakeVecZnx,
+            GGLWESwitchingKeyEncryptSkFamily<B> + VecZnxSwithcDegree + VecZnxAddScalarInplace + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>:
+            ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretPrepared<B> + ScratchAvailable + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {
@@ -94,7 +95,7 @@ impl<DataSelf: DataMut> GGLWESwitchingKey<DataSelf> {
            );
        });

-        let (mut sk_out_tmp, scratch2) = scratch1.take_glwe_secret_exec(n, sk_out.rank());
+        let (mut sk_out_tmp, scratch2) = scratch1.take_glwe_secret_prepared(n, sk_out.rank());
        {
            let (mut tmp, _) = scratch2.take_scalar_znx(n, 1);
            (0..sk_out.rank()).for_each(|i| {
--- a/core/src/encryption/gglwe_tsk.rs
+++ b/core/src/encryption/gglwe_tsk.rs
@@ -8,19 +8,22 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecret, TakeGLWESecretExec,
-    layouts::{GGLWETensorKey, GLWESecret, GGLWESwitchingKey, Infos, prepared::GLWESecretExec},
+    TakeGLWESecret, TakeGLWESecretPrepared,
+    layouts::{
+        GGLWESwitchingKey, GGLWETensorKey, GLWESecret, Infos,
+        prepared::{GLWESecretPrepared, Prepare},
+    },
    trait_families::GLWEDecryptFamily,
 };

-use crate::trait_families::{GGLWETensorKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWETensorKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl GGLWETensorKey<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
    where
-        Module<B>: GGLWETensorKeyEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWETensorKeyEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
-        GLWESecretExec::bytes_of(module, n, rank)
+        GLWESecretPrepared::bytes_of(module, n, rank)
            + module.vec_znx_dft_alloc_bytes(n, rank, 1)
            + module.vec_znx_big_alloc_bytes(n, 1, 1)
            + module.vec_znx_dft_alloc_bytes(n, 1, 1)
@@ -39,8 +42,10 @@ impl<DataSelf: DataMut> GGLWETensorKey<DataSelf> {
        sigma: f64,
        scratch: &mut Scratch<B>,
    ) where
-        Module<B>: GGLWETensorKeyEncryptSkFamily<B> + VecZnxSwithcDegree + VecZnxAddScalarInplace + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeGLWESecretExec<B> + TakeScalarZnx + TakeVecZnx,
+        Module<B>:
+            GGLWETensorKeyEncryptSkFamily<B> + VecZnxSwithcDegree + VecZnxAddScalarInplace + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>:
+            ScratchAvailable + TakeVecZnxDft<B> + TakeVecZnxBig<B> + TakeGLWESecretPrepared<B> + TakeScalarZnx + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {
@@ -52,8 +57,8 @@ impl<DataSelf: DataMut> GGLWETensorKey<DataSelf> {

        let rank: usize = self.rank();

-        let (mut sk_dft_prep, scratch1) = scratch.take_glwe_secret_exec(n, rank);
-        sk_dft_prep.prepare(module, &sk);
+        let (mut sk_dft_prep, scratch1) = scratch.take_glwe_secret_prepared(n, rank);
+        sk_dft_prep.prepare(module, &sk, scratch1);

        let (mut sk_dft, scratch2) = scratch1.take_vec_znx_dft(n, rank, 1);

--- a/core/src/encryption/ggsw_ct.rs
+++ b/core/src/encryption/ggsw_ct.rs
@@ -6,7 +6,7 @@ use sampling::source::Source;

 use crate::{
    TakeGLWEPt,
-    layouts::{GGSWCiphertext, GLWECiphertext, Infos, prepared::GLWESecretExec},
+    layouts::{GGSWCiphertext, GLWECiphertext, Infos, prepared::GLWESecretPrepared},
 };

 use crate::trait_families::GLWEEncryptSkFamily;
@@ -31,7 +31,7 @@ impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
        &mut self,
        module: &Module<B>,
        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        source_xa: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
--- a/core/src/encryption/glwe_ct.rs
+++ b/core/src/encryption/glwe_ct.rs
@@ -13,7 +13,7 @@ use crate::{
    dist::Distribution,
    layouts::{
        GLWECiphertext, GLWEPlaintext, Infos,
-        prepared::{GLWEPublicKeyExec, GLWESecretExec},
+        prepared::{GLWEPublicKeyPrepared, GLWESecretPrepared},
    },
    trait_families::{GLWEEncryptPkFamily, GLWEEncryptSkFamily},
 };
@@ -42,7 +42,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
        &mut self,
        module: &Module<B>,
        pt: &GLWEPlaintext<DataPt>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        source_xa: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
@@ -78,7 +78,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
    pub fn encrypt_zero_sk<DataSk: DataRef, B: Backend>(
        &mut self,
        module: &Module<B>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        source_xa: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
@@ -113,7 +113,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
        &mut self,
        module: &Module<B>,
        pt: Option<(&GLWEPlaintext<DataPt>, usize)>,
-        sk: &GLWESecretExec<DataSk, B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
        source_xa: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
@@ -143,7 +143,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
        &mut self,
        module: &Module<B>,
        pt: &GLWEPlaintext<DataPt>,
-        pk: &GLWEPublicKeyExec<DataPk, B>,
+        pk: &GLWEPublicKeyPrepared<DataPk, B>,
        source_xu: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
@@ -166,7 +166,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
    pub fn encrypt_zero_pk<DataPk: DataRef, B: Backend>(
        &mut self,
        module: &Module<B>,
-        pk: &GLWEPublicKeyExec<DataPk, B>,
+        pk: &GLWEPublicKeyPrepared<DataPk, B>,
        source_xu: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
@@ -190,7 +190,7 @@ impl<DataSelf: DataMut> GLWECiphertext<DataSelf> {
        &mut self,
        module: &Module<B>,
        pt: Option<(&GLWEPlaintext<DataPt>, usize)>,
-        pk: &GLWEPublicKeyExec<DataPk, B>,
+        pk: &GLWEPublicKeyPrepared<DataPk, B>,
        source_xu: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
@@ -283,7 +283,7 @@ pub(crate) fn glwe_encrypt_sk_internal<DataCt: DataMut, DataPt: DataRef, DataSk:
    cols: usize,
    compressed: bool,
    pt: Option<(&GLWEPlaintext<DataPt>, usize)>,
-    sk: &GLWESecretExec<DataSk, B>,
+    sk: &GLWESecretPrepared<DataSk, B>,
    source_xa: &mut Source,
    source_xe: &mut Source,
    sigma: f64,
--- a/core/src/encryption/glwe_pk.rs
+++ b/core/src/encryption/glwe_pk.rs
@@ -7,7 +7,7 @@ use sampling::source::Source;

 use crate::{
    dist::Distribution,
-    layouts::{GLWECiphertext, GLWEPublicKey, Infos, prepared::GLWESecretExec},
+    layouts::{GLWECiphertext, GLWEPublicKey, Infos, prepared::GLWESecretPrepared},
 };

 use crate::trait_families::GLWEEncryptSkFamily;
@@ -16,7 +16,7 @@ impl<D: DataMut> GLWEPublicKey<D> {
    pub fn generate_from_sk<S: DataRef, B: Backend>(
        &mut self,
        module: &Module<B>,
-        sk: &GLWESecretExec<S, B>,
+        sk: &GLWESecretPrepared<S, B>,
        source_xa: &mut Source,
        source_xe: &mut Source,
        sigma: f64,
--- a/core/src/encryption/glwe_to_lwe_ksk.rs
+++ b/core/src/encryption/glwe_to_lwe_ksk.rs
@@ -8,18 +8,18 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecret, TakeGLWESecretExec,
-    layouts::{GLWESecret, GGLWESwitchingKey, GLWEToLWESwitchingKey, LWESecret, prepared::GLWESecretExec},
+    TakeGLWESecret, TakeGLWESecretPrepared,
+    layouts::{GGLWESwitchingKey, GLWESecret, GLWEToLWESwitchingKey, LWESecret, prepared::GLWESecretPrepared},
 };

-use crate::trait_families::{GGLWEEncryptSkFamily, GGLWESwitchingKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWEEncryptSkFamily, GGLWESwitchingKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl GLWEToLWESwitchingKey<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank_in: usize) -> usize
    where
-        Module<B>: GGLWEEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWEEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
-        GLWESecretExec::bytes_of(module, n, rank_in)
+        GLWESecretPrepared::bytes_of(module, n, rank_in)
            + (GGLWESwitchingKey::encrypt_sk_scratch_space(module, n, basek, k, rank_in, 1) | GLWESecret::bytes_of(n, rank_in))
    }
 }
@@ -41,8 +41,8 @@ impl<D: DataMut> GLWEToLWESwitchingKey<D> {
            + VecZnxAutomorphismInplace
            + VecZnxSwithcDegree
            + VecZnxAddScalarInplace
-            + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretExec<B> + TakeVecZnx,
+            + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretPrepared<B> + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {
--- a/core/src/encryption/lwe_ksk.rs
+++ b/core/src/encryption/lwe_ksk.rs
@@ -8,19 +8,19 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecret, TakeGLWESecretExec,
-    layouts::{GLWESecret, GGLWESwitchingKey, Infos, LWESecret, LWESwitchingKey, prepared::GLWESecretExec},
+    TakeGLWESecret, TakeGLWESecretPrepared,
+    layouts::{GGLWESwitchingKey, GLWESecret, Infos, LWESecret, LWESwitchingKey, prepared::GLWESecretPrepared},
 };

-use crate::trait_families::{GGLWEEncryptSkFamily, GGLWESwitchingKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWEEncryptSkFamily, GGLWESwitchingKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl LWESwitchingKey<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize) -> usize
    where
-        Module<B>: GGLWEEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWEEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
        GLWESecret::bytes_of(n, 1)
-            + GLWESecretExec::bytes_of(module, n, 1)
+            + GLWESecretPrepared::bytes_of(module, n, 1)
            + GGLWESwitchingKey::encrypt_sk_scratch_space(module, n, basek, k, 1, 1)
    }
 }
@@ -42,8 +42,8 @@ impl<D: DataMut> LWESwitchingKey<D> {
            + VecZnxAutomorphismInplace
            + VecZnxSwithcDegree
            + VecZnxAddScalarInplace
-            + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretExec<B> + TakeVecZnx,
+            + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretPrepared<B> + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {
--- a/core/src/encryption/lwe_to_glwe_ksk.rs
+++ b/core/src/encryption/lwe_to_glwe_ksk.rs
@@ -8,16 +8,16 @@ use backend::hal::{
 use sampling::source::Source;

 use crate::{
-    TakeGLWESecret, TakeGLWESecretExec,
-    layouts::{GLWESecret, GGLWESwitchingKey, LWESecret, LWEToGLWESwitchingKey},
+    TakeGLWESecret, TakeGLWESecretPrepared,
+    layouts::{GGLWESwitchingKey, GLWESecret, LWESecret, LWEToGLWESwitchingKey},
 };

-use crate::trait_families::{GGLWEEncryptSkFamily, GGLWESwitchingKeyEncryptSkFamily, GLWESecretExecModuleFamily};
+use crate::trait_families::{GGLWEEncryptSkFamily, GGLWESwitchingKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};

 impl LWEToGLWESwitchingKey<Vec<u8>> {
    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank_out: usize) -> usize
    where
-        Module<B>: GGLWEEncryptSkFamily<B> + GLWESecretExecModuleFamily<B>,
+        Module<B>: GGLWEEncryptSkFamily<B> + GLWESecretPreparedModuleFamily<B>,
    {
        GGLWESwitchingKey::encrypt_sk_scratch_space(module, n, basek, k, 1, rank_out) + GLWESecret::bytes_of(n, 1)
    }
@@ -40,8 +40,8 @@ impl<D: DataMut> LWEToGLWESwitchingKey<D> {
            + VecZnxAutomorphismInplace
            + VecZnxSwithcDegree
            + VecZnxAddScalarInplace
-            + GLWESecretExecModuleFamily<B>,
-        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretExec<B> + TakeVecZnx,
+            + GLWESecretPreparedModuleFamily<B>,
+        Scratch<B>: ScratchAvailable + TakeScalarZnx + TakeVecZnxDft<B> + TakeGLWESecretPrepared<B> + TakeVecZnx,
    {
        #[cfg(debug_assertions)]
        {