updated repo for publishing (#74)

2026-02-10 21:26:41 +01:00 · 2025-08-17 14:57:39 +02:00
parent 0be569eca0
commit 62eb87cc07
244 changed files with 374 additions and 539 deletions
--- a/poulpy-core/src/noise/gglwe_ct.rs
+++ b/poulpy-core/src/noise/gglwe_ct.rs
@@ -0,0 +1,73 @@
+use poulpy_backend::hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftFromVecZnx, VecZnxDftToVecZnxBigConsume,
+        VecZnxNormalizeTmpBytes, VecZnxSubScalarInplace, ZnxZero,
+    },
+    layouts::{Backend, DataRef, Module, ScalarZnx, ScratchOwned},
+    oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl},
+};
+
+use crate::layouts::{GGLWECiphertext, GLWECiphertext, GLWEPlaintext, Infos, prepared::GLWESecretPrepared};
+
+impl<D: DataRef> GGLWECiphertext<D> {
+    pub fn assert_noise<B, DataSk, DataWant>(
+        self,
+        module: &Module<B>,
+        sk: &GLWESecretPrepared<DataSk, B>,
+        pt_want: &ScalarZnx<DataWant>,
+        max_noise: f64,
+    ) where
+        DataSk: DataRef,
+        DataWant: DataRef,
+        Module<B>: VecZnxDftAllocBytes
+            + VecZnxBigAllocBytes
+            + VecZnxDftFromVecZnx<B>
+            + SvpApplyInplace<B>
+            + VecZnxDftToVecZnxBigConsume<B>
+            + VecZnxBigAddInplace<B>
+            + VecZnxBigAddSmallInplace<B>
+            + VecZnxBigNormalize<B>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxSubScalarInplace,
+        B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+    {
+        let digits: usize = self.digits();
+        let basek: usize = self.basek();
+        let k: usize = self.k();
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GLWECiphertext::decrypt_scratch_space(
+            module,
+            self.n(),
+            basek,
+            k,
+        ));
+        let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(self.n(), basek, k);
+
+        (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());
+
+                module.vec_znx_sub_scalar_inplace(
+                    &mut pt.data,
+                    0,
+                    (digits - 1) + row_i * digits,
+                    pt_want,
+                    col_i,
+                );
+
+                let noise_have: f64 = pt.data.std(basek, 0).log2();
+
+                assert!(
+                    noise_have <= max_noise,
+                    "noise_have: {} > max_noise: {}",
+                    noise_have,
+                    max_noise
+                );
+
+                pt.data.zero();
+            });
+        });
+    }
+}
--- a/poulpy-core/src/noise/ggsw_ct.rs
+++ b/poulpy-core/src/noise/ggsw_ct.rs
@@ -0,0 +1,145 @@
+use poulpy_backend::hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, VecZnxAddScalarInplace, VecZnxBigAddInplace,
+        VecZnxBigAddSmallInplace, VecZnxBigAlloc, VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
+        VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftFromVecZnx, VecZnxDftToVecZnxBigConsume, VecZnxDftToVecZnxBigTmpA,
+        VecZnxNormalizeTmpBytes, VecZnxSubABInplace, ZnxZero,
+    },
+    layouts::{Backend, DataRef, Module, ScalarZnx, ScratchOwned, VecZnxBig, VecZnxDft},
+    oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl},
+};
+
+use crate::layouts::{GGSWCiphertext, GLWECiphertext, GLWEPlaintext, Infos, prepared::GLWESecretPrepared};
+
+impl<D: DataRef> GGSWCiphertext<D> {
+    pub fn assert_noise<B, DataSk, DataScalar, F>(
+        &self,
+        module: &Module<B>,
+        sk_prepared: &GLWESecretPrepared<DataSk, B>,
+        pt_want: &ScalarZnx<DataScalar>,
+        max_noise: F,
+    ) where
+        DataSk: DataRef,
+        DataScalar: DataRef,
+        Module<B>: VecZnxDftAllocBytes
+            + VecZnxBigAllocBytes
+            + VecZnxDftFromVecZnx<B>
+            + SvpApplyInplace<B>
+            + VecZnxDftToVecZnxBigConsume<B>
+            + VecZnxBigAddInplace<B>
+            + VecZnxBigAddSmallInplace<B>
+            + VecZnxBigNormalize<B>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxBigAlloc<B>
+            + VecZnxDftAlloc<B>
+            + VecZnxBigNormalizeTmpBytes
+            + VecZnxDftToVecZnxBigTmpA<B>
+            + VecZnxAddScalarInplace
+            + VecZnxSubABInplace,
+        B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+        F: Fn(usize) -> f64,
+    {
+        let basek: usize = self.basek();
+        let k: usize = self.k();
+        let digits: usize = self.digits();
+
+        let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(self.n(), basek, k);
+        let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(self.n(), basek, k);
+        let mut pt_dft: VecZnxDft<Vec<u8>, B> = module.vec_znx_dft_alloc(self.n(), 1, self.size());
+        let mut pt_big: VecZnxBig<Vec<u8>, B> = module.vec_znx_big_alloc(self.n(), 1, self.size());
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+            GLWECiphertext::decrypt_scratch_space(module, self.n(), basek, k) | module.vec_znx_normalize_tmp_bytes(self.n()),
+        );
+
+        (0..self.rank() + 1).for_each(|col_j| {
+            (0..self.rows()).for_each(|row_i| {
+                module.vec_znx_add_scalar_inplace(&mut pt.data, 0, (digits - 1) + row_i * digits, pt_want, 0);
+
+                // mul with sk[col_j-1]
+                if col_j > 0 {
+                    module.vec_znx_dft_from_vec_znx(1, 0, &mut pt_dft, 0, &pt.data, 0);
+                    module.svp_apply_inplace(&mut pt_dft, 0, &sk_prepared.data, col_j - 1);
+                    module.vec_znx_dft_to_vec_znx_big_tmp_a(&mut pt_big, 0, &mut pt_dft, 0);
+                    module.vec_znx_big_normalize(basek, &mut pt.data, 0, &pt_big, 0, scratch.borrow());
+                }
+
+                self.at(row_i, col_j)
+                    .decrypt(module, &mut pt_have, sk_prepared, scratch.borrow());
+
+                module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt.data, 0);
+
+                let std_pt: f64 = pt_have.data.std(basek, 0).log2();
+                let noise: f64 = max_noise(col_j);
+                println!("{} {}", std_pt, noise);
+                assert!(std_pt <= noise, "{} > {}", std_pt, noise);
+
+                pt.data.zero();
+            });
+        });
+    }
+}
+
+impl<D: DataRef> GGSWCiphertext<D> {
+    pub fn print_noise<B, DataSk, DataScalar>(
+        &self,
+        module: &Module<B>,
+        sk_prepared: &GLWESecretPrepared<DataSk, B>,
+        pt_want: &ScalarZnx<DataScalar>,
+    ) where
+        DataSk: DataRef,
+        DataScalar: DataRef,
+        Module<B>: VecZnxDftAllocBytes
+            + VecZnxBigAllocBytes
+            + VecZnxDftFromVecZnx<B>
+            + SvpApplyInplace<B>
+            + VecZnxDftToVecZnxBigConsume<B>
+            + VecZnxBigAddInplace<B>
+            + VecZnxBigAddSmallInplace<B>
+            + VecZnxBigNormalize<B>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxBigAlloc<B>
+            + VecZnxDftAlloc<B>
+            + VecZnxBigNormalizeTmpBytes
+            + VecZnxDftToVecZnxBigTmpA<B>
+            + VecZnxAddScalarInplace
+            + VecZnxSubABInplace,
+        B: Backend + TakeVecZnxDftImpl<B> + TakeVecZnxBigImpl<B> + ScratchOwnedAllocImpl<B> + ScratchOwnedBorrowImpl<B>,
+    {
+        let basek: usize = self.basek();
+        let k: usize = self.k();
+        let digits: usize = self.digits();
+
+        let mut pt: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(self.n(), basek, k);
+        let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(self.n(), basek, k);
+        let mut pt_dft: VecZnxDft<Vec<u8>, B> = module.vec_znx_dft_alloc(self.n(), 1, self.size());
+        let mut pt_big: VecZnxBig<Vec<u8>, B> = module.vec_znx_big_alloc(self.n(), 1, self.size());
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
+            GLWECiphertext::decrypt_scratch_space(module, self.n(), basek, k) | module.vec_znx_normalize_tmp_bytes(module.n()),
+        );
+
+        (0..self.rank() + 1).for_each(|col_j| {
+            (0..self.rows()).for_each(|row_i| {
+                module.vec_znx_add_scalar_inplace(&mut pt.data, 0, (digits - 1) + row_i * digits, pt_want, 0);
+
+                // mul with sk[col_j-1]
+                if col_j > 0 {
+                    module.vec_znx_dft_from_vec_znx(1, 0, &mut pt_dft, 0, &pt.data, 0);
+                    module.svp_apply_inplace(&mut pt_dft, 0, &sk_prepared.data, col_j - 1);
+                    module.vec_znx_dft_to_vec_znx_big_tmp_a(&mut pt_big, 0, &mut pt_dft, 0);
+                    module.vec_znx_big_normalize(basek, &mut pt.data, 0, &pt_big, 0, scratch.borrow());
+                }
+
+                self.at(row_i, col_j)
+                    .decrypt(module, &mut pt_have, sk_prepared, scratch.borrow());
+
+                module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt.data, 0);
+
+                let std_pt: f64 = pt_have.data.std(basek, 0).log2();
+                println!("col: {} row: {}: {}", col_j, row_i, std_pt);
+                pt.data.zero();
+            });
+        });
+    }
+}
--- a/poulpy-core/src/noise/glwe_ct.rs
+++ b/poulpy-core/src/noise/glwe_ct.rs
@@ -0,0 +1,57 @@
+use poulpy_backend::hal::{
+    api::{
+        ScratchOwnedAlloc, ScratchOwnedBorrow, SvpApplyInplace, VecZnxBigAddInplace, VecZnxBigAddSmallInplace,
+        VecZnxBigAllocBytes, VecZnxBigNormalize, VecZnxDftAllocBytes, VecZnxDftFromVecZnx, VecZnxDftToVecZnxBigConsume,
+        VecZnxNormalizeInplace, VecZnxNormalizeTmpBytes, VecZnxSubABInplace,
+    },
+    layouts::{Backend, DataRef, Module, ScratchOwned},
+    oep::{ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl},
+};
+
+use crate::{
+    layouts::GLWEPlaintext,
+    layouts::prepared::GLWESecretPrepared,
+    layouts::{GLWECiphertext, Infos},
+};
+
+impl<D: DataRef> GLWECiphertext<D> {
+    pub fn assert_noise<B, DataSk, DataPt>(
+        &self,
+        module: &Module<B>,
+        sk_prepared: &GLWESecretPrepared<DataSk, B>,
+        pt_want: &GLWEPlaintext<DataPt>,
+        max_noise: f64,
+    ) where
+        DataSk: DataRef,
+        DataPt: DataRef,
+        Module<B>: VecZnxDftAllocBytes
+            + VecZnxBigAllocBytes
+            + VecZnxDftFromVecZnx<B>
+            + SvpApplyInplace<B>
+            + VecZnxDftToVecZnxBigConsume<B>
+            + VecZnxBigAddInplace<B>
+            + VecZnxBigAddSmallInplace<B>
+            + VecZnxBigNormalize<B>
+            + VecZnxNormalizeTmpBytes
+            + VecZnxSubABInplace
+            + VecZnxNormalizeInplace<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());
+
+        let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(GLWECiphertext::decrypt_scratch_space(
+            module,
+            self.n(),
+            self.basek(),
+            self.k(),
+        ));
+
+        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());
+
+        let noise_have: f64 = pt_have.data.std(self.basek(), 0).log2();
+        assert!(noise_have <= max_noise, "{} {}", noise_have, max_noise);
+    }
+}
--- a/poulpy-core/src/noise/mod.rs
+++ b/poulpy-core/src/noise/mod.rs
@@ -0,0 +1,151 @@
+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,
+    basek: usize,
+    var_xs: f64,
+    var_msg: f64,
+    var_a_err: f64,
+    var_gct_err_lhs: f64,
+    var_gct_err_rhs: f64,
+    rank_in: f64,
+    a_logq: usize,
+    b_logq: usize,
+) -> f64 {
+    let a_logq: usize = a_logq.min(b_logq);
+    let a_cols: usize = a_logq.div_ceil(basek);
+
+    let b_scale: f64 = (b_logq as f64).exp2();
+    let a_scale: f64 = ((b_logq - a_logq) as f64).exp2();
+
+    let base: f64 = (basek as f64).exp2();
+    let var_base: f64 = base * base / 12f64;
+
+    // lhs = a_cols * n * (var_base * var_gct_err_lhs + var_e_a * var_msg * p^2)
+    // rhs = a_cols * n * var_base * var_gct_err_rhs * var_xs
+    let mut noise: f64 = (a_cols as f64) * n * var_base * (var_gct_err_lhs + var_xs * var_gct_err_rhs);
+    noise += var_msg * var_a_err * a_scale * a_scale * n;
+    noise *= rank_in;
+    noise /= b_scale * b_scale;
+    noise
+}
+
+#[allow(clippy::too_many_arguments)]
+#[allow(dead_code)]
+pub(crate) fn log2_std_noise_gglwe_product(
+    n: f64,
+    basek: usize,
+    var_xs: f64,
+    var_msg: f64,
+    var_a_err: f64,
+    var_gct_err_lhs: f64,
+    var_gct_err_rhs: f64,
+    rank_in: f64,
+    a_logq: usize,
+    b_logq: usize,
+) -> f64 {
+    let mut noise: f64 = var_noise_gglwe_product(
+        n,
+        basek,
+        var_xs,
+        var_msg,
+        var_a_err,
+        var_gct_err_lhs,
+        var_gct_err_rhs,
+        rank_in,
+        a_logq,
+        b_logq,
+    );
+    noise = noise.sqrt();
+    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,
+    basek: usize,
+    var_xs: f64,
+    var_msg: f64,
+    var_a0_err: f64,
+    var_a1_err: f64,
+    var_gct_err_lhs: f64,
+    var_gct_err_rhs: f64,
+    rank: f64,
+    k_in: usize,
+    k_ggsw: usize,
+) -> f64 {
+    let a_logq: usize = k_in.min(k_ggsw);
+    let a_cols: usize = a_logq.div_ceil(basek);
+
+    let b_scale: f64 = (k_ggsw as f64).exp2();
+    let a_scale: f64 = ((k_ggsw - a_logq) as f64).exp2();
+
+    let base: f64 = (basek as f64).exp2();
+    let var_base: f64 = base * base / 12f64;
+
+    // lhs = a_cols * n * (var_base * var_gct_err_lhs + var_e_a * var_msg * p^2)
+    // rhs = a_cols * n * var_base * var_gct_err_rhs * var_xs
+    let mut noise: f64 = (rank + 1.0) * (a_cols as f64) * n * var_base * (var_gct_err_lhs + var_xs * var_gct_err_rhs);
+    noise += var_msg * var_a0_err * a_scale * a_scale * n;
+    noise += var_msg * var_a1_err * a_scale * a_scale * n * var_xs * rank;
+    noise = noise.sqrt();
+    noise /= b_scale;
+    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,
+    basek: usize,
+    col: usize,
+    var_xs: f64,
+    var_a_err: f64,
+    var_gct_err_lhs: f64,
+    var_gct_err_rhs: f64,
+    rank: f64,
+    k_ct: usize,
+    k_ksk: usize,
+    k_tsk: usize,
+) -> f64 {
+    let var_si_x_sj: f64 = n * var_xs * var_xs;
+
+    // Initial KS for col = 0
+    let mut noise: f64 = var_noise_gglwe_product(
+        n,
+        basek,
+        var_xs,
+        var_xs,
+        var_a_err,
+        var_gct_err_lhs,
+        var_gct_err_rhs,
+        rank,
+        k_ct,
+        k_ksk,
+    );
+
+    // Other GGSW reconstruction for col > 0
+    if col > 0 {
+        noise += var_noise_gglwe_product(
+            n,
+            basek,
+            var_xs,
+            var_si_x_sj,
+            var_a_err + 1f64 / 12.0,
+            var_gct_err_lhs,
+            var_gct_err_rhs,
+            rank,
+            k_ct,
+            k_tsk,
+        );
+        noise += n * noise * var_xs * 0.5;
+    }
+
+    noise = noise.sqrt();
+    noise.log2().min(-1.0) // max noise is [-2^{-1}, 2^{-1}]
+}