poulpy · arnaucube's git mirror

glwe ops

Jean-Philippe Bossuat jeanphilippe.bossuat@gmail.com

Thu, 16 Oct 2025 11:25:55 +0200

commit

bbc664fa389ec780cc159cea7fe772644ad8def9

parent

919bbfd41d4f9be02ef48cc4d584696768a6357a

6 files changed, 40 insertions(+), 27 deletions(-)

jump to

poulpy-core/src/automorphism/mod.rs

poulpy-core/src/keyswitching/mod.rs

poulpy-core/src/lib.rs

poulpy-core/src/operations/glwe.rs

poulpy-hal/src/api/module.rs

poulpy-hal/src/layouts/module.rs

M poulpy-core/src/automorphism/mod.rs → poulpy-core/src/automorphism/mod.rs

@@ -1,3 +1,7 @@
 mod gglwe_atk;
 mod ggsw_ct;
 mod glwe_ct;
+
+pub use gglwe_atk::*;
+pub use ggsw_ct::*;
+pub use glwe_ct::*;

M poulpy-core/src/keyswitching/mod.rs → poulpy-core/src/keyswitching/mod.rs

@@ -4,6 +4,6 @@ mod glwe_ct;
 mod lwe_ct;
 
 pub use gglwe_ct::*;
-pub use gglwe_ct::*;
+//pub use gglwe_ct::*;
 pub use glwe_ct::*;
 pub use lwe_ct::*;

M poulpy-core/src/lib.rs → poulpy-core/src/lib.rs

@@ -19,6 +19,7 @@ pub use dist::*;
 pub use external_product::*;
 pub use glwe_packing::*;
 pub use keyswitching::*;
+pub use automorphism::*;
 
 pub use encryption::SIGMA;

M poulpy-core/src/operations/glwe.rs → poulpy-core/src/operations/glwe.rs

@@ -4,7 +4,7 @@ VecZnxAdd, VecZnxAddInplace, VecZnxCopy, VecZnxMulXpMinusOne, VecZnxMulXpMinusOneInplace, VecZnxNegateInplace,
         VecZnxNormalize, VecZnxNormalizeInplace, VecZnxRotate, VecZnxRotateInplace, VecZnxRshInplace, VecZnxSub,
         VecZnxSubInplace, VecZnxSubNegateInplace,
     },
-    layouts::{Backend, DataMut, Module, Scratch, VecZnx, ZnxZero},
+    layouts::{Backend, DataMut, Scratch, VecZnx, ZnxZero},
 };
 
 use crate::layouts::{GLWE, GLWEInfos, GLWEPlaintext, GLWEToMut, GLWEToRef, LWEInfos, SetGLWEInfos, TorusPrecision};
@@ -19,11 +19,11 @@
 impl<D: DataMut> GLWEOperations for GLWE<D> where GLWE<D>: GLWEToMut + GLWEInfos {}
 
 pub trait GLWEOperations: GLWEToMut + GLWEInfos + SetGLWEInfos + Sized {
-    fn add<A, B, BACKEND: Backend>(&mut self, module: &Module<BACKEND>, a: &A, b: &B)
+    fn add<A, B, M>(&mut self, module: &M, a: &A, b: &B)
     where
         A: GLWEToRef + GLWEInfos,
         B: GLWEToRef + GLWEInfos,
-        Module<BACKEND>: VecZnxAdd + VecZnxCopy,
+        M: VecZnxAdd + VecZnxCopy,
     {
         #[cfg(debug_assertions)]
         {
@@ -66,10 +66,10 @@ self.set_base2k(a.base2k());
         self.set_k(set_k_binary(self, a, b));
     }
 
-    fn add_inplace<A, BACKEND: Backend>(&mut self, module: &Module<BACKEND>, a: &A)
+    fn add_inplace<A, M>(&mut self, module: &M, a: &A)
     where
         A: GLWEToRef + GLWEInfos,
-        Module<BACKEND>: VecZnxAddInplace,
+        M: VecZnxAddInplace,
     {
         #[cfg(debug_assertions)]
         {
@@ -88,11 +88,11 @@
         self.set_k(set_k_unary(self, a))
     }
 
-    fn sub<A, B, BACKEND: Backend>(&mut self, module: &Module<BACKEND>, a: &A, b: &B)
+    fn sub<A, B, M>(&mut self, module: &M, a: &A, b: &B)
     where
         A: GLWEToRef + GLWEInfos,
         B: GLWEToRef + GLWEInfos,
-        Module<BACKEND>: VecZnxSub + VecZnxCopy + VecZnxNegateInplace,
+        M: VecZnxSub + VecZnxCopy + VecZnxNegateInplace,
     {
         #[cfg(debug_assertions)]
         {
@@ -136,10 +136,10 @@ self.set_base2k(a.base2k());
         self.set_k(set_k_binary(self, a, b));
     }
 
-    fn sub_inplace_ab<A, BACKEND: Backend>(&mut self, module: &Module<BACKEND>, a: &A)
+    fn sub_inplace_ab<A, M>(&mut self, module: &M, a: &A)
     where
         A: GLWEToRef + GLWEInfos,
-        Module<BACKEND>: VecZnxSubInplace,
+        M: VecZnxSubInplace,
     {
         #[cfg(debug_assertions)]
         {
@@ -158,10 +158,10 @@
         self.set_k(set_k_unary(self, a))
     }
 
-    fn sub_inplace_ba<A, BACKEND: Backend>(&mut self, module: &Module<BACKEND>, a: &A)
+    fn sub_inplace_ba<A, M>(&mut self, module: &M, a: &A)
     where
         A: GLWEToRef + GLWEInfos,
-        Module<BACKEND>: VecZnxSubNegateInplace,
+        M: VecZnxSubNegateInplace,
     {
         #[cfg(debug_assertions)]
         {
@@ -180,10 +180,10 @@
         self.set_k(set_k_unary(self, a))
     }
 
-    fn rotate<A, B: Backend>(&mut self, module: &Module<B>, k: i64, a: &A)
+    fn rotate<A, M>(&mut self, module: &M, k: i64, a: &A)
     where
         A: GLWEToRef + GLWEInfos,
-        Module<B>: VecZnxRotate,
+        M: VecZnxRotate,
     {
         #[cfg(debug_assertions)]
         {
@@ -202,9 +202,9 @@ self.set_base2k(a.base2k());
         self.set_k(set_k_unary(self, a))
     }
 
-    fn rotate_inplace<B: Backend>(&mut self, module: &Module<B>, k: i64, scratch: &mut Scratch<B>)
+    fn rotate_inplace<M, BE: Backend>(&mut self, module: &M, k: i64, scratch: &mut Scratch<BE>)
     where
-        Module<B>: VecZnxRotateInplace<B>,
+        M: VecZnxRotateInplace<BE>,
     {
         let self_mut: &mut GLWE<&mut [u8]> = &mut self.to_mut();
 
@@ -213,10 +213,10 @@ module.vec_znx_rotate_inplace(k, &mut self_mut.data, i, scratch);
         });
     }
 
-    fn mul_xp_minus_one<A, B: Backend>(&mut self, module: &Module<B>, k: i64, a: &A)
+    fn mul_xp_minus_one<A, M>(&mut self, module: &M, k: i64, a: &A)
     where
         A: GLWEToRef + GLWEInfos,
-        Module<B>: VecZnxMulXpMinusOne,
+        M: VecZnxMulXpMinusOne,
     {
         #[cfg(debug_assertions)]
         {
@@ -235,9 +235,9 @@ self.set_base2k(a.base2k());
         self.set_k(set_k_unary(self, a))
     }
 
-    fn mul_xp_minus_one_inplace<B: Backend>(&mut self, module: &Module<B>, k: i64, scratch: &mut Scratch<B>)
+    fn mul_xp_minus_one_inplace<M, BE: Backend>(&mut self, module: &M, k: i64, scratch: &mut Scratch<BE>)
     where
-        Module<B>: VecZnxMulXpMinusOneInplace<B>,
+        M: VecZnxMulXpMinusOneInplace<BE>,
     {
         let self_mut: &mut GLWE<&mut [u8]> = &mut self.to_mut();
 
@@ -268,9 +268,9 @@ self.set_k(a.k().min(self.max_k()));
         self.set_base2k(a.base2k());
     }
 
-    fn rsh<B: Backend>(&mut self, module: &Module<B>, k: usize, scratch: &mut Scratch<B>)
+    fn rsh<M, BE: Backend>(&mut self, module: &M, k: usize, scratch: &mut Scratch<BE>)
     where
-        Module<B>: VecZnxRshInplace<B>,
+        M: VecZnxRshInplace<BE>,
     {
         let base2k: usize = self.base2k().into();
         (0..(self.rank() + 1).into()).for_each(|i| {
@@ -278,10 +278,10 @@ module.vec_znx_rsh_inplace(base2k, k, &mut self.to_mut().data, i, scratch);
         })
     }
 
-    fn normalize<A, B: Backend>(&mut self, module: &Module<B>, a: &A, scratch: &mut Scratch<B>)
+    fn normalize<A, M, BE: Backend>(&mut self, module: &M, a: &A, scratch: &mut Scratch<BE>)
     where
         A: GLWEToRef + GLWEInfos,
-        Module<B>: VecZnxNormalize<B>,
+        M: VecZnxNormalize<BE>,
     {
         #[cfg(debug_assertions)]
         {
@@ -307,9 +307,9 @@ self.set_base2k(a.base2k());
         self.set_k(a.k().min(self.k()));
     }
 
-    fn normalize_inplace<B: Backend>(&mut self, module: &Module<B>, scratch: &mut Scratch<B>)
+    fn normalize_inplace<M, BE: Backend>(&mut self, module: &M, scratch: &mut Scratch<BE>)
     where
-        Module<B>: VecZnxNormalizeInplace<B>,
+        M: VecZnxNormalizeInplace<BE>,
     {
         let self_mut: &mut GLWE<&mut [u8]> = &mut self.to_mut();
         (0..(self_mut.rank() + 1).into()).for_each(|i| {

M poulpy-hal/src/api/module.rs → poulpy-hal/src/api/module.rs

@@ -8,3 +8,9 @@
 pub trait ModuleN {
     fn n(&self) -> usize;
 }
+
+pub trait ModuleLogN where Self: ModuleN{
+    fn log_n(&self) -> usize{
+        (u64::BITS - (self.n() as u64-1).leading_zeros()) as usize
+    }
+}

M poulpy-hal/src/layouts/module.rs → poulpy-hal/src/layouts/module.rs

@@ -2,7 +2,7 @@ use std::{fmt::Display, marker::PhantomData, ptr::NonNull};
 
 use rand_distr::num_traits::Zero;
 
-use crate::{GALOISGENERATOR, api::ModuleN};
+use crate::{api::{ModuleLogN, ModuleN}, GALOISGENERATOR};
 
 #[allow(clippy::missing_safety_doc)]
 pub trait Backend: Sized {
@@ -85,6 +85,8 @@ fn cyclotomic_order(&self) -> i64 {
         (self.n() << 1) as _
     }
 }
+
+impl<BE: Backend> ModuleLogN for Module<BE> where Self: ModuleN{}
 
 impl<BE: Backend> CyclotomicOrder for Module<BE> where Self: ModuleN {}