arnaucube/poulpy
1
0
Fork 0
mirror of https://github.com/arnaucube/poulpy.git synced 2026-02-10 13:16:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Added LWE-GLWE conversion & LWE Keyswitch, improved LUT generation

Browse Source
This commit is contained in:
Jean-Philippe Bossuat
2025-07-07 11:09:04 +02:00
parent c4a517e9c3
commit 5234c3fc63
28 changed files with 979 additions and 782 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/src/gglwe/automorphism_key.rs
View File

@@ -66,7 +66,7 @@ impl<C: AsRef<[u8]>> GetRow<FFT64> for GLWEAutomorphismKey<C, FFT64> {
col_j: usize,
res: &mut FourierGLWECiphertext<R, FFT64>,
) {
module.mat_znx_dft_get_row(&mut res.data, &self.key.0.data, row_i, col_j);
module.mat_znx_dft_get_row(&mut res.data, &self.key.key.data, row_i, col_j);
}
}
@@ -78,6 +78,6 @@ impl<C: AsMut<[u8]> + AsRef<[u8]>> SetRow<FFT64> for GLWEAutomorphismKey<C, FFT6
col_j: usize,
a: &FourierGLWECiphertext<R, FFT64>,
) {
module.mat_znx_dft_set_row(&mut self.key.0.data, row_i, col_j, &a.data);
module.mat_znx_dft_set_row(&mut self.key.key.data, row_i, col_j, &a.data);
}
}

125
core/src/gglwe/encryption.rs
View File

@@ -1,5 +1,6 @@
use backend::{
FFT64, Module, ScalarZnx, ScalarZnxDftOps, ScalarZnxOps, Scratch, VecZnxAlloc, VecZnxDftAlloc, VecZnxOps, ZnxInfos, ZnxZero,
FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDftOps, ScalarZnxOps, Scratch, VecZnxAlloc, VecZnxDftAlloc, VecZnxOps,
ZnxInfos, ZnxView, ZnxViewMut, ZnxZero,
};
use sampling::source::Source;
@@ -9,7 +10,7 @@ use crate::{
};
impl GGLWECiphertext<Vec<u8>, FFT64> {
pub fn generate_from_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
let size = k.div_ceil(basek);
GLWECiphertext::encrypt_sk_scratch_space(module, basek, k)
+ module.bytes_of_vec_znx(rank + 1, size)
@@ -17,7 +18,7 @@ impl GGLWECiphertext<Vec<u8>, FFT64> {
+ module.bytes_of_vec_znx_dft(rank + 1, size)
}
pub fn generate_from_pk_scratch_space(_module: &Module<FFT64>, _basek: usize, _k: usize, _rank: usize) -> usize {
pub fn encrypt_pk_scratch_space(_module: &Module<FFT64>, _basek: usize, _k: usize, _rank: usize) -> usize {
unimplemented!()
}
}
@@ -35,20 +36,30 @@ impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GGLWECiphertext<DataSelf, FFT64> {
) {
#[cfg(debug_assertions)]
{
assert_eq!(self.rank_in(), pt.cols());
assert_eq!(self.rank_out(), sk.rank());
assert_eq!(
self.rank_in(),
pt.cols(),
"self.rank_in(): {} != pt.cols(): {}",
self.rank_in(),
pt.cols()
);
assert_eq!(
self.rank_out(),
sk.rank(),
"self.rank_out(): {} != sk.rank(): {}",
self.rank_out(),
sk.rank()
);
assert_eq!(self.n(), module.n());
assert_eq!(sk.n(), module.n());
assert_eq!(pt.n(), module.n());
assert!(
scratch.available()
>= GGLWECiphertext::generate_from_sk_scratch_space(module, self.basek(), self.k(), self.rank()),
"scratch.available: {} < GGLWECiphertext::generate_from_sk_scratch_space(module, self.rank()={}, \
self.size()={}): {}",
scratch.available() >= GGLWECiphertext::encrypt_sk_scratch_space(module, self.basek(), self.k(), self.rank()),
"scratch.available: {} < GGLWECiphertext::encrypt_sk_scratch_space(module, self.rank()={}, self.size()={}): {}",
scratch.available(),
self.rank(),
self.size(),
GGLWECiphertext::generate_from_sk_scratch_space(module, self.basek(), self.k(), self.rank())
GGLWECiphertext::encrypt_sk_scratch_space(module, self.basek(), self.k(), self.rank())
);
assert!(
self.rows() * self.digits() * self.basek() <= self.k(),
@@ -110,17 +121,25 @@ impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GGLWECiphertext<DataSelf, FFT64> {
}
impl GLWESwitchingKey<Vec<u8>, FFT64> {
pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
GGLWECiphertext::generate_from_sk_scratch_space(module, basek, k, rank)
pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank_in: usize, rank_out: usize) -> usize {
GGLWECiphertext::encrypt_sk_scratch_space(module, basek, k, rank_out)
+ module.bytes_of_scalar_znx(rank_in)
+ FourierGLWESecret::bytes_of(module, rank_out)
}
pub fn encrypt_pk_scratch_space(module: &Module<FFT64>, _basek: usize, _k: usize, _rank: usize) -> usize {
GGLWECiphertext::generate_from_pk_scratch_space(module, _basek, _k, _rank)
pub fn encrypt_pk_scratch_space(
module: &Module<FFT64>,
_basek: usize,
_k: usize,
_rank_in: usize,
_rank_out: usize,
) -> usize {
GGLWECiphertext::encrypt_pk_scratch_space(module, _basek, _k, _rank_out)
}
}
impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GLWESwitchingKey<DataSelf, FFT64> {
pub fn generate_from_sk<DataSkIn: AsRef<[u8]>, DataSkOut: AsRef<[u8]>>(
pub fn encrypt_sk<DataSkIn: AsRef<[u8]>, DataSkOut: AsRef<[u8]>>(
&mut self,
module: &Module<FFT64>,
sk_in: &GLWESecret<DataSkIn>,
@@ -130,30 +149,62 @@ impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GLWESwitchingKey<DataSelf, FFT64> {
sigma: f64,
scratch: &mut Scratch,
) {
self.0.encrypt_sk(
#[cfg(debug_assertions)]
{
assert!(sk_in.n() <= module.n());
assert!(sk_out.n() <= module.n());
}
let (mut sk_in_tmp, scratch1) = scratch.tmp_scalar_znx(module, sk_in.rank());
sk_in_tmp.zero();
(0..sk_in.rank()).for_each(|i| {
sk_in_tmp
.at_mut(i, 0)
.iter_mut()
.step_by(module.n() / sk_in.n())
.zip(sk_in.data.at(i, 0).iter())
.for_each(|(x, y)| *x = *y);
});
let (mut sk_out_tmp, scratch2) = scratch1.tmp_fourier_glwe_secret(module, sk_out.rank());
(0..sk_out.rank()).for_each(|i| {
sk_out_tmp
.data
.at_mut(i, 0)
.chunks_exact_mut(module.n() / sk_out.n())
.zip(sk_out.data.at(i, 0).iter())
.for_each(|(a_chunk, &b_elem)| {
a_chunk.fill(b_elem);
});
});
self.key.encrypt_sk(
module,
&sk_in.data,
sk_out,
&sk_in_tmp,
&sk_out_tmp,
source_xa,
source_xe,
sigma,
scratch,
scratch2,
);
self.sk_in_n = sk_in.n();
self.sk_out_n = sk_out.n();
}
}
impl GLWEAutomorphismKey<Vec<u8>, FFT64> {
pub fn generate_from_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
GGLWECiphertext::generate_from_sk_scratch_space(module, basek, k, rank) + GLWESecret::bytes_of(module, rank)
pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
GLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k, rank, rank) + GLWESecret::bytes_of(module, rank)
}
pub fn generate_from_pk_scratch_space(module: &Module<FFT64>, _basek: usize, _k: usize, _rank: usize) -> usize {
GGLWECiphertext::generate_from_pk_scratch_space(module, _basek, _k, _rank)
pub fn encrypt_pk_scratch_space(module: &Module<FFT64>, _basek: usize, _k: usize, _rank: usize) -> usize {
GLWESwitchingKey::encrypt_pk_scratch_space(module, _basek, _k, _rank, _rank)
}
}
impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GLWEAutomorphismKey<DataSelf, FFT64> {
pub fn generate_from_sk<DataSk: AsRef<[u8]>>(
pub fn encrypt_sk<DataSk: AsRef<[u8]>>(
&mut self,
module: &Module<FFT64>,
p: i64,
@@ -170,21 +221,19 @@ impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GLWEAutomorphismKey<DataSelf, FFT64> {
assert_eq!(self.rank_out(), self.rank_in());
assert_eq!(sk.rank(), self.rank());
assert!(
scratch.available()
>= GLWEAutomorphismKey::generate_from_sk_scratch_space(module, self.basek(), self.k(), self.rank()),
"scratch.available(): {} < AutomorphismKey::generate_from_sk_scratch_space(module, self.rank()={}, \
self.size()={}): {}",
scratch.available() >= GLWEAutomorphismKey::encrypt_sk_scratch_space(module, self.basek(), self.k(), self.rank()),
"scratch.available(): {} < AutomorphismKey::encrypt_sk_scratch_space(module, self.rank()={}, self.size()={}): {}",
scratch.available(),
self.rank(),
self.size(),
GLWEAutomorphismKey::generate_from_sk_scratch_space(module, self.basek(), self.k(), self.rank())
GLWEAutomorphismKey::encrypt_sk_scratch_space(module, self.basek(), self.k(), self.rank())
)
}
let (mut sk_out_dft, scratch_1) = scratch.tmp_fourier_sk(module, sk.rank());
let (mut sk_out_dft, scratch_1) = scratch.tmp_fourier_glwe_secret(module, sk.rank());
{
let (mut sk_out, _) = scratch_1.tmp_sk(module, sk.rank());
let (mut sk_out, _) = scratch_1.tmp_glwe_secret(module, sk.rank());
(0..self.rank()).for_each(|i| {
module.scalar_znx_automorphism(
module.galois_element_inv(p),
@@ -197,7 +246,7 @@ impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GLWEAutomorphismKey<DataSelf, FFT64> {
sk_out_dft.set(module, &sk_out);
}
self.key.generate_from_sk(
self.key.encrypt_sk(
module,
&sk,
&sk_out_dft,
@@ -212,15 +261,15 @@ impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GLWEAutomorphismKey<DataSelf, FFT64> {
}
impl GLWETensorKey<Vec<u8>, FFT64> {
pub fn generate_from_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
GLWESecret::bytes_of(module, 1)
+ FourierGLWESecret::bytes_of(module, 1)
+ GLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k, rank)
+ GLWESwitchingKey::encrypt_sk_scratch_space(module, basek, k, rank, rank)
}
}
impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GLWETensorKey<DataSelf, FFT64> {
pub fn generate_from_sk<DataSk: AsRef<[u8]>>(
pub fn encrypt_sk<DataSk: AsRef<[u8]>>(
&mut self,
module: &Module<FFT64>,
sk: &FourierGLWESecret<DataSk, FFT64>,
@@ -238,15 +287,15 @@ impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> GLWETensorKey<DataSelf, FFT64> {
let rank: usize = self.rank();
let (mut sk_ij, scratch1) = scratch.tmp_sk(module, 1);
let (mut sk_ij_dft, scratch2) = scratch1.tmp_fourier_sk(module, 1);
let (mut sk_ij, scratch1) = scratch.tmp_glwe_secret(module, 1);
let (mut sk_ij_dft, scratch2) = scratch1.tmp_fourier_glwe_secret(module, 1);
(0..rank).for_each(|i| {
(i..rank).for_each(|j| {
module.svp_apply(&mut sk_ij_dft.data, 0, &sk.data, i, &sk.data, j);
module.scalar_znx_idft(&mut sk_ij.data, 0, &sk_ij_dft.data, 0, scratch2);
self.at_mut(i, j)
.generate_from_sk(module, &sk_ij, sk, source_xa, source_xe, sigma, scratch2);
.encrypt_sk(module, &sk_ij, sk, source_xa, source_xe, sigma, scratch2);
});
})
}

40
core/src/gglwe/keyswitch_key.rs
View File

@@ -2,7 +2,11 @@ use backend::{Backend, FFT64, MatZnxDft, MatZnxDftOps, Module};
use crate::{FourierGLWECiphertext, GGLWECiphertext, GetRow, Infos, SetRow};
pub struct GLWESwitchingKey<Data, B: Backend>(pub(crate) GGLWECiphertext<Data, B>);
pub struct GLWESwitchingKey<Data, B: Backend> {
pub(crate) key: GGLWECiphertext<Data, B>,
pub(crate) sk_in_n: usize, // Degree of sk_in
pub(crate) sk_out_n: usize, // Degree of sk_out
}
impl GLWESwitchingKey<Vec<u8>, FFT64> {
pub fn alloc(
@@ -14,9 +18,11 @@ impl GLWESwitchingKey<Vec<u8>, FFT64> {
rank_in: usize,
rank_out: usize,
) -> Self {
GLWESwitchingKey(GGLWECiphertext::alloc(
module, basek, k, rows, digits, rank_in, rank_out,
))
GLWESwitchingKey {
key: GGLWECiphertext::alloc(module, basek, k, rows, digits, rank_in, rank_out),
sk_in_n: 0,
sk_out_n: 0,
}
}
pub fn bytes_of(
@@ -36,33 +42,41 @@ impl<T, B: Backend> Infos for GLWESwitchingKey<T, B> {
type Inner = MatZnxDft<T, B>;
fn inner(&self) -> &Self::Inner {
self.0.inner()
self.key.inner()
}
fn basek(&self) -> usize {
self.0.basek()
self.key.basek()
}
fn k(&self) -> usize {
self.0.k()
self.key.k()
}
}
impl<T, B: Backend> GLWESwitchingKey<T, B> {
pub fn rank(&self) -> usize {
self.0.data.cols_out() - 1
self.key.data.cols_out() - 1
}
pub fn rank_in(&self) -> usize {
self.0.data.cols_in()
self.key.data.cols_in()
}
pub fn rank_out(&self) -> usize {
self.0.data.cols_out() - 1
self.key.data.cols_out() - 1
}
pub fn digits(&self) -> usize {
self.0.digits()
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
}
}
@@ -74,7 +88,7 @@ impl<C: AsRef<[u8]>> GetRow<FFT64> for GLWESwitchingKey<C, FFT64> {
col_j: usize,
res: &mut FourierGLWECiphertext<R, FFT64>,
) {
module.mat_znx_dft_get_row(&mut res.data, &self.0.data, row_i, col_j);
module.mat_znx_dft_get_row(&mut res.data, &self.key.data, row_i, col_j);
}
}
@@ -86,6 +100,6 @@ impl<C: AsMut<[u8]> + AsRef<[u8]>> SetRow<FFT64> for GLWESwitchingKey<C, FFT64>
col_j: usize,
a: &FourierGLWECiphertext<R, FFT64>,
) {
module.mat_znx_dft_set_row(&mut self.0.data, row_i, col_j, &a.data);
module.mat_znx_dft_set_row(&mut self.key.data, row_i, col_j, &a.data);
}
}

12
core/src/gglwe/test_fft64/automorphism_key.rs
View File

@@ -70,7 +70,7 @@ fn test_automorphism(
let mut source_xa: Source = Source::new([0u8; 32]);
let mut scratch: ScratchOwned = ScratchOwned::new(
GLWEAutomorphismKey::generate_from_sk_scratch_space(&module, basek, k_apply, rank)
GLWEAutomorphismKey::encrypt_sk_scratch_space(&module, basek, k_apply, rank)
| FourierGLWECiphertext::decrypt_scratch_space(&module, basek, k_out)
| GLWEAutomorphismKey::automorphism_scratch_space(&module, basek, k_out, k_in, k_apply, digits, rank),
);
@@ -79,7 +79,7 @@ fn test_automorphism(
sk.fill_ternary_prob(0.5, &mut source_xs);
// gglwe_{s1}(s0) = s0 -> s1
auto_key_in.generate_from_sk(
auto_key_in.encrypt_sk(
&module,
p0,
&sk,
@@ -90,7 +90,7 @@ fn test_automorphism(
);
// gglwe_{s2}(s1) -> s1 -> s2
auto_key_apply.generate_from_sk(
auto_key_apply.encrypt_sk(
&module,
p1,
&sk,
@@ -185,7 +185,7 @@ fn test_automorphism_inplace(
let mut source_xa: Source = Source::new([0u8; 32]);
let mut scratch: ScratchOwned = ScratchOwned::new(
GLWEAutomorphismKey::generate_from_sk_scratch_space(&module, basek, k_apply, rank)
GLWEAutomorphismKey::encrypt_sk_scratch_space(&module, basek, k_apply, rank)
| FourierGLWECiphertext::decrypt_scratch_space(&module, basek, k_in)
| GLWEAutomorphismKey::automorphism_inplace_scratch_space(&module, basek, k_in, k_apply, digits, rank),
);
@@ -194,7 +194,7 @@ fn test_automorphism_inplace(
sk.fill_ternary_prob(0.5, &mut source_xs);
// gglwe_{s1}(s0) = s0 -> s1
auto_key.generate_from_sk(
auto_key.encrypt_sk(
&module,
p0,
&sk,
@@ -205,7 +205,7 @@ fn test_automorphism_inplace(
);
// gglwe_{s2}(s1) -> s1 -> s2
auto_key_apply.generate_from_sk(
auto_key_apply.encrypt_sk(
&module,
p1,
&sk,

31
core/src/gglwe/test_fft64/gglwe.rs
View File

@@ -144,7 +144,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, digits: usize, rank
let mut source_xa: Source = Source::new([0u8; 32]);
let mut scratch: ScratchOwned = ScratchOwned::new(
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_ksk, rank_out)
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_ksk, rank_in, rank_out)
| FourierGLWECiphertext::decrypt_scratch_space(&module, basek, k_ksk),
);
@@ -155,7 +155,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, digits: usize, rank
sk_out.fill_ternary_prob(0.5, &mut source_xs);
let sk_out_dft: FourierGLWESecret<Vec<u8>, FFT64> = FourierGLWESecret::from(&module, &sk_out);
ksk.generate_from_sk(
ksk.encrypt_sk(
&module,
&sk_in,
&sk_out_dft,
@@ -234,8 +234,13 @@ fn test_key_switch(
let mut source_xa: Source = Source::new([0u8; 32]);
let mut scratch: ScratchOwned = ScratchOwned::new(
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_ksk, rank_in_s0s1 | rank_out_s0s1)
| FourierGLWECiphertext::decrypt_scratch_space(&module, basek, k_out)
GLWESwitchingKey::encrypt_sk_scratch_space(
&module,
basek,
k_ksk,
rank_in_s0s1,
rank_in_s0s1 | rank_out_s0s1,
) | FourierGLWECiphertext::decrypt_scratch_space(&module, basek, k_out)
| GLWESwitchingKey::keyswitch_scratch_space(
&module,
basek,
@@ -260,7 +265,7 @@ fn test_key_switch(
let sk2_dft: FourierGLWESecret<Vec<u8>, FFT64> = FourierGLWESecret::from(&module, &sk2);
// gglwe_{s1}(s0) = s0 -> s1
ct_gglwe_s0s1.generate_from_sk(
ct_gglwe_s0s1.encrypt_sk(
&module,
&sk0,
&sk1_dft,
@@ -271,7 +276,7 @@ fn test_key_switch(
);
// gglwe_{s2}(s1) -> s1 -> s2
ct_gglwe_s1s2.generate_from_sk(
ct_gglwe_s1s2.encrypt_sk(
&module,
&sk1,
&sk2_dft,
@@ -348,7 +353,7 @@ fn test_key_switch_inplace(
let mut source_xa: Source = Source::new([0u8; 32]);
let mut scratch: ScratchOwned = ScratchOwned::new(
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_ksk, rank_out)
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_ksk, rank_in, rank_out)
| FourierGLWECiphertext::decrypt_scratch_space(&module, basek, k_ksk)
| GLWESwitchingKey::keyswitch_inplace_scratch_space(&module, basek, k_ct, k_ksk, digits, rank_out),
);
@@ -365,7 +370,7 @@ fn test_key_switch_inplace(
let sk2_dft: FourierGLWESecret<Vec<u8>, FFT64> = FourierGLWESecret::from(&module, &sk2);
// gglwe_{s1}(s0) = s0 -> s1
ct_gglwe_s0s1.generate_from_sk(
ct_gglwe_s0s1.encrypt_sk(
&module,
&sk0,
&sk1_dft,
@@ -376,7 +381,7 @@ fn test_key_switch_inplace(
);
// gglwe_{s2}(s1) -> s1 -> s2
ct_gglwe_s1s2.generate_from_sk(
ct_gglwe_s1s2.encrypt_sk(
&module,
&sk1,
&sk2_dft,
@@ -459,7 +464,7 @@ fn test_external_product(
let mut source_xa: Source = Source::new([0u8; 32]);
let mut scratch: ScratchOwned = ScratchOwned::new(
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_in, rank_out)
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_in, rank_in, rank_out)
| FourierGLWECiphertext::decrypt_scratch_space(&module, basek, k_out)
| GLWESwitchingKey::external_product_scratch_space(&module, basek, k_out, k_in, k_ggsw, digits, rank_out)
| GGSWCiphertext::encrypt_sk_scratch_space(&module, basek, k_ggsw, rank_out),
@@ -477,7 +482,7 @@ fn test_external_product(
let sk_out_dft: FourierGLWESecret<Vec<u8>, FFT64> = FourierGLWESecret::from(&module, &sk_out);
// gglwe_{s1}(s0) = s0 -> s1
ct_gglwe_in.generate_from_sk(
ct_gglwe_in.encrypt_sk(
&module,
&sk_in,
&sk_out_dft,
@@ -580,7 +585,7 @@ fn test_external_product_inplace(
let mut source_xa: Source = Source::new([0u8; 32]);
let mut scratch: ScratchOwned = ScratchOwned::new(
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_ct, rank_out)
GLWESwitchingKey::encrypt_sk_scratch_space(&module, basek, k_ct, rank_in, rank_out)
| FourierGLWECiphertext::decrypt_scratch_space(&module, basek, k_ct)
| GLWESwitchingKey::external_product_inplace_scratch_space(&module, basek, k_ct, k_ggsw, digits, rank_out)
| GGSWCiphertext::encrypt_sk_scratch_space(&module, basek, k_ggsw, rank_out),
@@ -598,7 +603,7 @@ fn test_external_product_inplace(
let sk_out_dft: FourierGLWESecret<Vec<u8>, FFT64> = FourierGLWESecret::from(&module, &sk_out);
// gglwe_{s1}(s0) = s0 -> s1
ct_gglwe.generate_from_sk(
ct_gglwe.encrypt_sk(
&module,
&sk_in,
&sk_out_dft,

4
core/src/gglwe/test_fft64/tensor_key.rs
View File

@@ -23,7 +23,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize
let mut source_xe: Source = Source::new([0u8; 32]);
let mut source_xa: Source = Source::new([0u8; 32]);
let mut scratch: ScratchOwned = ScratchOwned::new(GLWETensorKey::generate_from_sk_scratch_space(
let mut scratch: ScratchOwned = ScratchOwned::new(GLWETensorKey::encrypt_sk_scratch_space(
&module,
basek,
tensor_key.k(),
@@ -34,7 +34,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize
sk.fill_ternary_prob(0.5, &mut source_xs);
let sk_dft: FourierGLWESecret<Vec<u8>, FFT64> = FourierGLWESecret::from(&module, &sk);
tensor_key.generate_from_sk(
tensor_key.encrypt_sk(
&module,
&sk_dft,
&mut source_xa,