remaining in encryption + noise

2026-02-10 13:16:44 +01:00 · 2025-10-17 19:56:10 -04:00
parent 957345f9ea
commit a282e88126
9 changed files with 527 additions and 308 deletions
--- a/poulpy-core/src/encryption/compressed/gglwe_tsk.rs
+++ b/poulpy-core/src/encryption/compressed/gglwe_tsk.rs
@@ -11,6 +11,7 @@ use poulpy_hal::{
 use crate::{
    ScratchTakeCore,
    encryption::compressed::gglwe_ksk::GLWESwitchingKeyCompressedEncryptSk,
+    encryption::gglwe_tsk::TensorKeyEncryptSk,
    layouts::{
        GGLWEInfos, GLWEInfos, GLWESecret, GLWESecretToRef, GetDist, LWEInfos, Rank, TensorKey,
        compressed::{TensorKeyCompressed, TensorKeyCompressedToMut},
@@ -18,58 +19,81 @@ use crate::{
 };

 impl TensorKeyCompressed<Vec<u8>> {
-    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
    where
        A: GGLWEInfos,
-        Module<B>: ModuleN
-            + SvpPPolBytesOf
-            + SvpPPolAlloc<B>
-            + VecZnxNormalizeTmpBytes
-            + VecZnxDftBytesOf
-            + VecZnxNormalizeTmpBytes
-            + VecZnxBigBytesOf,
+        M: GGLWETensorKeyCompressedEncryptSk<BE>,
    {
-        TensorKey::encrypt_sk_tmp_bytes(module, infos)
+        module.gglwe_tensor_key_compressed_encrypt_sk_tmp_bytes(infos)
    }
 }

-pub trait GGLWETensorKeyCompressedEncryptSk<B: Backend> {
+impl<DataSelf: DataMut> TensorKeyCompressed<DataSelf> {
+    pub fn encrypt_sk<DataSk: DataRef, BE: Backend>(
+        &mut self,
+        module: &Module<BE>,
+        sk: &GLWESecret<DataSk>,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        GLWESecret<DataSk>: GetDist,
+        Module<BE>: GGLWETensorKeyCompressedEncryptSk<BE>,
+    {
+        module.gglwe_tensor_key_encrypt_sk(self, sk, seed_xa, source_xe, scratch);
+    }
+}
+
+pub trait GGLWETensorKeyCompressedEncryptSk<BE: Backend> {
+
+    fn gglwe_tensor_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos;
+
    fn gglwe_tensor_key_encrypt_sk<R, S>(
        &self,
        res: &mut R,
        sk: &S,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
+        scratch: &mut Scratch<BE>,
    ) where
        R: TensorKeyCompressedToMut,
        S: GLWESecretToRef + GetDist;
 }

-impl<B: Backend> GGLWETensorKeyCompressedEncryptSk<B> for Module<B>
+impl<BE: Backend> GGLWETensorKeyCompressedEncryptSk<BE> for Module<BE>
 where
-    Module<B>: ModuleN
-        + GLWESwitchingKeyCompressedEncryptSk<B>
-        + VecZnxDftApply<B>
-        + SvpApplyDftToDft<B>
-        + VecZnxIdftApplyTmpA<B>
-        + VecZnxBigNormalize<B>
-        + SvpPrepare<B>
-        + SvpPPolAllocBytesImpl<B>
+    Module<BE>: ModuleN
+        + GLWESwitchingKeyCompressedEncryptSk<BE>
+        + TensorKeyEncryptSk<BE>
+        + VecZnxDftApply<BE>
+        + SvpApplyDftToDft<BE>
+        + VecZnxIdftApplyTmpA<BE>
+        + VecZnxBigNormalize<BE>
+        + SvpPrepare<BE>
+        + SvpPPolAllocBytesImpl<BE>
        + SvpPPolBytesOf
-        + VecZnxDftAllocBytesImpl<B>
-        + VecZnxBigAllocBytesImpl<B>
+        + VecZnxDftAllocBytesImpl<BE>
+        + VecZnxBigAllocBytesImpl<BE>
        + VecZnxDftBytesOf
        + VecZnxBigBytesOf,
-    Scratch<B>: ScratchTakeBasic + ScratchTakeCore<B>,
+    Scratch<BE>: ScratchTakeBasic + ScratchTakeCore<BE>,
 {
+    fn gglwe_tensor_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGLWEInfos
+    {
+        self.tensor_key_encrypt_sk_tmp_bytes(infos)
+    }
+
    fn gglwe_tensor_key_encrypt_sk<R, S>(
        &self,
        res: &mut R,
        sk: &S,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
+        scratch: &mut Scratch<BE>,
    ) where
        R: TensorKeyCompressedToMut,
        S: GLWESecretToRef + GetDist,
@@ -130,35 +154,4 @@ where
            }
        }
    }
-}
-
-impl<DataSelf: DataMut> TensorKeyCompressed<DataSelf> {
-    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        sk: &GLWESecret<DataSk>,
-        seed_xa: [u8; 32],
-        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
-    ) where
-        GLWESecret<DataSk>: GetDist,
-        Module<B>: GGLWETensorKeyCompressedEncryptSk<B>,
-    {
-        module.gglwe_tensor_key_encrypt_sk(self, sk, seed_xa, source_xe, scratch);
-    }
-}
-
-impl<DataSelf: DataMut> TensorKeyCompressed<DataSelf> {
-    pub fn encrypt_sk<DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        sk: &GLWESecret<DataSk>,
-        seed_xa: [u8; 32],
-        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: GGLWETensorKeyCompressedEncryptSk<B>,
-    {
-        module.gglwe_tensor_key_encrypt_sk(self, sk, seed_xa, source_xe, scratch);
-    }
-}
+}
--- a/poulpy-core/src/encryption/compressed/ggsw_ct.rs
+++ b/poulpy-core/src/encryption/compressed/ggsw_ct.rs
@@ -1,49 +1,52 @@
 use poulpy_hal::{
-    api::{ModuleN, VecZnxAddScalarInplace, VecZnxDftBytesOf, VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes},
+    api::{ModuleN, VecZnxAddScalarInplace, VecZnxNormalizeInplace},
    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, ScalarZnxToRef, Scratch, ZnxZero},
    source::Source,
 };

 use crate::{
    ScratchTakeCore,
-    encryption::{SIGMA, glwe_ct::GLWEEncryptSkInternal},
+    encryption::{SIGMA, ggsw_ct::GGSWEncryptSk, glwe_ct::GLWEEncryptSkInternal},
    layouts::{
-        GGSW, GGSWInfos, GLWEInfos, LWEInfos,
+        GGSWInfos, GLWEInfos, LWEInfos,
        compressed::{GGSWCompressed, GGSWCompressedToMut},
        prepared::{GLWESecretPrepared, GLWESecretPreparedToRef},
    },
 };

 impl GGSWCompressed<Vec<u8>> {
-    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
    where
        A: GGSWInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
+        M: GGSWCompressedEncryptSk<BE>,
    {
-        GGSW::encrypt_sk_tmp_bytes(module, infos)
+        module.ggsw_compressed_encrypt_sk_tmp_bytes(infos)
    }
 }

-pub trait GGSWCompressedEncryptSk<B: Backend> {
-    fn ggsw_compressed_encrypt_sk<R, P, S>(
-        &self,
-        res: &mut R,
-        pt: &P,
-        sk: &S,
+impl<DataSelf: DataMut> GGSWCompressed<DataSelf> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, BE: Backend>(
+        &mut self,
+        module: &Module<BE>,
+        pt: &ScalarZnx<DataPt>,
+        sk: &GLWESecretPrepared<DataSk, BE>,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
+        scratch: &mut Scratch<BE>,
    ) where
-        R: GGSWCompressedToMut,
-        P: ScalarZnxToRef,
-        S: GLWESecretPreparedToRef<B>;
+        Module<BE>: GGSWCompressedEncryptSk<BE>,
+    {
+        module.ggsw_compressed_encrypt_sk(self, pt, sk, seed_xa, source_xe, scratch);
+    }
 }

-impl<B: Backend> GGSWCompressedEncryptSk<B> for Module<B>
-where
-    Module<B>: ModuleN + GLWEEncryptSkInternal<B> + VecZnxAddScalarInplace + VecZnxNormalizeInplace<B>,
-    Scratch<B>: ScratchTakeCore<B>,
-{
+
+pub trait GGSWCompressedEncryptSk<BE: Backend> {
+    fn ggsw_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GGSWInfos;
+
    fn ggsw_compressed_encrypt_sk<R, P, S>(
        &self,
        res: &mut R,
@@ -51,14 +54,39 @@ where
        sk: &S,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
+        scratch: &mut Scratch<BE>,
    ) where
        R: GGSWCompressedToMut,
        P: ScalarZnxToRef,
-        S: GLWESecretPreparedToRef<B>,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GGSWCompressedEncryptSk<BE> for Module<BE>
+where
+    Module<BE>: ModuleN + GLWEEncryptSkInternal<BE> + GGSWEncryptSk<BE> + VecZnxAddScalarInplace + VecZnxNormalizeInplace<BE>,
+    Scratch<BE>: ScratchTakeCore<BE>,
+{
+    fn ggsw_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+        where A: GGSWInfos,
+    {
+        self.ggsw_encrypt_sk_tmp_bytes(infos)
+    }
+
+    fn ggsw_compressed_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GGSWCompressedToMut,
+        P: ScalarZnxToRef,
+        S: GLWESecretPreparedToRef<BE>,
    {
        let res: &mut GGSWCompressed<&mut [u8]> = &mut res.to_mut();
-        let sk: &GLWESecretPrepared<&[u8], B> = &sk.to_ref();
+        let sk: &GLWESecretPrepared<&[u8], BE> = &sk.to_ref();
        let pt: &ScalarZnx<&[u8]> = &pt.to_ref();

        #[cfg(debug_assertions)]
@@ -111,21 +139,4 @@ where
            }
        }
    }
-}
-
-impl<DataSelf: DataMut> GGSWCompressed<DataSelf> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: &ScalarZnx<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
-        seed_xa: [u8; 32],
-        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: GGSWCompressedEncryptSk<B>,
-    {
-        module.ggsw_compressed_encrypt_sk(self, pt, sk, seed_xa, source_xe, scratch);
-    }
-}
+}
--- a/poulpy-core/src/encryption/compressed/glwe_ct.rs
+++ b/poulpy-core/src/encryption/compressed/glwe_ct.rs
@@ -5,7 +5,7 @@ use poulpy_hal::{
 };

 use crate::{
-    encryption::{SIGMA, glwe_ct::GLWEEncryptSkInternal},
+    encryption::{SIGMA, glwe_ct::{GLWEEncryptSk, GLWEEncryptSkInternal}},
    layouts::{
        GLWE, GLWEInfos, GLWEPlaintext, GLWEPlaintextToRef, LWEInfos,
        compressed::{GLWECompressed, GLWECompressedToMut},
@@ -14,34 +14,38 @@ use crate::{
 };

 impl GLWECompressed<Vec<u8>> {
-    pub fn encrypt_sk_tmp_bytes<B: Backend, A>(module: &Module<B>, infos: &A) -> usize
+    pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
    where
        A: GLWEInfos,
-        Module<B>: VecZnxNormalizeTmpBytes + VecZnxDftBytesOf,
+        M: GLWECompressedEncryptSk<BE>,
    {
-        GLWE::encrypt_sk_tmp_bytes(module, infos)
+        module.glwe_compressed_encrypt_sk_tmp_bytes(infos)
    }
 }

-pub trait GLWECompressedEncryptSk<B: Backend> {
-    fn glwe_compressed_encrypt_sk<R, P, S>(
-        &self,
-        res: &mut R,
-        pt: &P,
-        sk: &S,
+impl<D: DataMut> GLWECompressed<D> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, BE: Backend>(
+        &mut self,
+        module: &Module<BE>,
+        pt: &GLWEPlaintext<DataPt>,
+        sk: &GLWESecretPrepared<DataSk, BE>,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
+        scratch: &mut Scratch<BE>,
    ) where
-        R: GLWECompressedToMut,
-        P: GLWEPlaintextToRef,
-        S: GLWESecretPreparedToRef<B>;
+        Module<BE>: GLWECompressedEncryptSk<BE>,
+    {
+        module.glwe_compressed_encrypt_sk(self, pt, sk, seed_xa, source_xe, scratch);
+    }
 }

-impl<B: Backend> GLWECompressedEncryptSk<B> for Module<B>
-where
-    Module<B>: GLWEEncryptSkInternal<B>,
-{
+
+pub trait GLWECompressedEncryptSk<BE: Backend> {
+    fn glwe_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos;
+
    fn glwe_compressed_encrypt_sk<R, P, S>(
        &self,
        res: &mut R,
@@ -49,11 +53,37 @@ where
        sk: &S,
        seed_xa: [u8; 32],
        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
+        scratch: &mut Scratch<BE>,
    ) where
        R: GLWECompressedToMut,
        P: GLWEPlaintextToRef,
-        S: GLWESecretPreparedToRef<B>,
+        S: GLWESecretPreparedToRef<BE>;
+}
+
+impl<BE: Backend> GLWECompressedEncryptSk<BE> for Module<BE>
+where
+    Module<BE>: GLWEEncryptSkInternal<BE> + GLWEEncryptSk<BE>,
+{
+
+    fn glwe_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize
+    where
+        A: GLWEInfos,
+    {
+        self.glwe_encrypt_sk_tmp_bytes(infos)
+    }
+
+    fn glwe_compressed_encrypt_sk<R, P, S>(
+        &self,
+        res: &mut R,
+        pt: &P,
+        sk: &S,
+        seed_xa: [u8; 32],
+        source_xe: &mut Source,
+        scratch: &mut Scratch<BE>,
+    ) where
+        R: GLWECompressedToMut,
+        P: GLWEPlaintextToRef,
+        S: GLWESecretPreparedToRef<BE>,
    {
        let res: &mut GLWECompressed<&mut [u8]> = &mut res.to_mut();
        let mut source_xa: Source = Source::new(seed_xa);
@@ -75,21 +105,4 @@ where

        res.seed = seed_xa;
    }
-}
-
-impl<D: DataMut> GLWECompressed<D> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
-        &mut self,
-        module: &Module<B>,
-        pt: &GLWEPlaintext<DataPt>,
-        sk: &GLWESecretPrepared<DataSk, B>,
-        seed_xa: [u8; 32],
-        source_xe: &mut Source,
-        scratch: &mut Scratch<B>,
-    ) where
-        Module<B>: GLWECompressedEncryptSk<B>,
-    {
-        module.glwe_compressed_encrypt_sk(self, pt, sk, seed_xa, source_xe, scratch);
-    }
-}
+}