mirror of
https://github.com/arnaucube/poulpy.git
synced 2026-02-10 05:06:44 +01:00
Refactor of GGSW key-switch to enable easier implementation of GGSW automorphism
This commit is contained in:
Jean-Philippe Bossuat
@@ -1,7 +1,8 @@
|
||||
use base2k::{
|
||||
Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx,
|
||||
ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxAlloc, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch,
|
||||
VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, ZnxInfos, ZnxZero,
|
||||
ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBigAlloc, VecZnxBigOps,
|
||||
VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, VecZnxToMut,
|
||||
VecZnxToRef, ZnxInfos, ZnxZero,
|
||||
};
|
||||
use sampling::source::Source;
|
||||
|
||||
@@ -81,6 +82,26 @@ impl GGSWCiphertext<Vec<u8>, FFT64> {
|
||||
+ module.bytes_of_vec_znx_dft(rank + 1, size)
|
||||
}
|
||||
|
||||
pub(crate) fn expand_row_scratch_space(module: &Module<FFT64>, self_size: usize, tsk_size: usize, rank: usize) -> usize {
|
||||
let tmp_dft_i: usize = module.bytes_of_vec_znx_dft(rank + 1, tsk_size);
|
||||
let tmp_dft_col_data: usize = module.bytes_of_vec_znx_dft(1, self_size);
|
||||
let vmp: usize = tmp_dft_col_data + module.vmp_apply_tmp_bytes(self_size, self_size, self_size, rank, rank, tsk_size);
|
||||
let tmp_idft: usize = module.bytes_of_vec_znx_big(1, tsk_size);
|
||||
let norm: usize = module.vec_znx_big_normalize_tmp_bytes();
|
||||
tmp_dft_i + ((tmp_dft_col_data + vmp) | (tmp_idft + norm))
|
||||
}
|
||||
|
||||
pub(crate) fn keyswitch_internal_col0_scratch_space(
|
||||
module: &Module<FFT64>,
|
||||
out_size: usize,
|
||||
in_size: usize,
|
||||
ksk_size: usize,
|
||||
rank: usize,
|
||||
) -> usize {
|
||||
GLWECiphertext::keyswitch_from_fourier_scratch_space(module, out_size, rank, in_size, rank, ksk_size)
|
||||
+ module.bytes_of_vec_znx_dft(rank + 1, in_size)
|
||||
}
|
||||
|
||||
pub fn keyswitch_scratch_space(
|
||||
module: &Module<FFT64>,
|
||||
out_size: usize,
|
||||
@@ -89,17 +110,12 @@ impl GGSWCiphertext<Vec<u8>, FFT64> {
|
||||
tsk_size: usize,
|
||||
rank: usize,
|
||||
) -> usize {
|
||||
let tmp_dft_out: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
|
||||
let vmp_ksk: usize = module.bytes_of_vec_znx_dft(rank + 1, in_size)
|
||||
+ GLWECiphertextFourier::keyswitch_scratch_space(module, out_size, rank, in_size, rank, ksk_size);
|
||||
let tmp_c0: usize = module.bytes_of_vec_znx_big(1, out_size);
|
||||
let tmp_dft_i: usize = module.bytes_of_vec_znx_dft(rank + 1, tsk_size);
|
||||
let vmp_tsk: usize = module.bytes_of_vec_znx_dft(1, out_size)
|
||||
+ module.vmp_apply_tmp_bytes(out_size, out_size, rank + 1, rank + 1, rank + 1, tsk_size);
|
||||
let tmp_idft: usize = module.bytes_of_vec_znx_big(1, tsk_size);
|
||||
let tmp_znx_small: usize = module.bytes_of_vec_znx(1, out_size);
|
||||
let norm: usize = module.vec_znx_big_normalize_tmp_bytes();
|
||||
tmp_dft_out + (vmp_ksk | (tmp_c0 + tmp_dft_i + (vmp_tsk | (tmp_idft + tmp_znx_small + norm))))
|
||||
let res_znx: usize = module.bytes_of_vec_znx(rank + 1, out_size);
|
||||
let ci_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
|
||||
let ks: usize = GGSWCiphertext::keyswitch_internal_col0_scratch_space(module, out_size, in_size, ksk_size, rank);
|
||||
let expand_rows: usize = GGSWCiphertext::expand_row_scratch_space(module, out_size, tsk_size, rank);
|
||||
let res_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
|
||||
res_znx + ci_dft + (ks | expand_rows | res_dft)
|
||||
}
|
||||
|
||||
pub fn automorphism_scratch_space(
|
||||
@@ -186,19 +202,19 @@ where
|
||||
k,
|
||||
};
|
||||
|
||||
(0..self.rows()).for_each(|row_j| {
|
||||
(0..self.rows()).for_each(|row_i| {
|
||||
vec_znx_pt.data.zero();
|
||||
|
||||
// Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
|
||||
module.vec_znx_add_scalar_inplace(&mut vec_znx_pt, 0, row_j, pt, 0);
|
||||
module.vec_znx_add_scalar_inplace(&mut vec_znx_pt, 0, row_i, pt, 0);
|
||||
module.vec_znx_normalize_inplace(basek, &mut vec_znx_pt, 0, scrach_2);
|
||||
|
||||
(0..cols).for_each(|col_i| {
|
||||
(0..cols).for_each(|col_j| {
|
||||
// rlwe encrypt of vec_znx_pt into vec_znx_ct
|
||||
|
||||
vec_znx_ct.encrypt_sk_private(
|
||||
module,
|
||||
Some((&vec_znx_pt, col_i)),
|
||||
Some((&vec_znx_pt, col_j)),
|
||||
sk_dft,
|
||||
source_xa,
|
||||
source_xe,
|
||||
@@ -214,167 +230,151 @@ where
|
||||
module.vec_znx_dft(&mut vec_znx_dft_ct, i, &vec_znx_ct, i);
|
||||
});
|
||||
|
||||
module.vmp_prepare_row(self, row_j, col_i, &vec_znx_dft_ct);
|
||||
self.set_row(module, row_i, col_j, &vec_znx_dft_ct);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
pub fn keyswitch<DataLhs, DataRhs0, DataRhs1>(
|
||||
pub(crate) fn expand_row<R, DataCi, DataTsk>(
|
||||
&mut self,
|
||||
module: &Module<FFT64>,
|
||||
lhs: &GGSWCiphertext<DataLhs, FFT64>,
|
||||
ksk: &GLWESwitchingKey<DataRhs0, FFT64>,
|
||||
tsk: &TensorKey<DataRhs1, FFT64>,
|
||||
col_j: usize,
|
||||
res: &mut R,
|
||||
ci_dft: &VecZnxDft<DataCi, FFT64>,
|
||||
tsk: &TensorKey<DataTsk, FFT64>,
|
||||
scratch: &mut Scratch,
|
||||
) where
|
||||
MatZnxDft<DataLhs, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
MatZnxDft<DataRhs0, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
MatZnxDft<DataRhs1, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
R: VecZnxToMut,
|
||||
VecZnxDft<DataCi, FFT64>: VecZnxDftToRef<FFT64>,
|
||||
MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
{
|
||||
#[cfg(debug_assertions)]
|
||||
{
|
||||
assert_eq!(
|
||||
self.rank(),
|
||||
lhs.rank(),
|
||||
"ggsw_out rank: {} != ggsw_in rank: {}",
|
||||
self.rank(),
|
||||
lhs.rank()
|
||||
);
|
||||
assert_eq!(
|
||||
lhs.rank(),
|
||||
ksk.rank(),
|
||||
"ggsw_in rank: {} != ksk rank: {}",
|
||||
lhs.rank(),
|
||||
ksk.rank()
|
||||
);
|
||||
assert_eq!(
|
||||
lhs.rank(),
|
||||
tsk.rank(),
|
||||
"ggsw_in rank: {} != tsk rank: {}",
|
||||
lhs.rank(),
|
||||
tsk.rank()
|
||||
);
|
||||
}
|
||||
|
||||
let cols: usize = self.rank() + 1;
|
||||
|
||||
// Example for rank 3:
|
||||
//
|
||||
// Note: M is a vector (m, Bm, B^2m, B^3m, ...), so each column is
|
||||
// actually composed of that many rows.
|
||||
// actually composed of that many rows and we focus on a specific row here
|
||||
// implicitely given ci_dft.
|
||||
//
|
||||
// # Input
|
||||
//
|
||||
// col 0: (-(a0s0 + a1s1 + a2s2) + M, a0 , a1 , a2 )
|
||||
// col 1: (-(b0s0 + b1s1 + b2s2) , b0 + M, b1 , b2 )
|
||||
// col 2: (-(c0s0 + c1s1 + c2s2) , c0 , c1 + M, c2 )
|
||||
// col 3: (-(d0s0 + d1s1 + d2s2) , d0 , d1 , d2 + M)
|
||||
// col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0 , a1 , a2 )
|
||||
// col 1: (0, 0, 0, 0)
|
||||
// col 2: (0, 0, 0, 0)
|
||||
// col 3: (0, 0, 0, 0)
|
||||
//
|
||||
// # Output
|
||||
//
|
||||
// col 0: (-(a0s0' + a1s1' + a2s2') + M, a0 , a1 , a2 )
|
||||
// col 1: (-(b0s0' + b1s1' + b2s2') , b0 + M, b1 , b2 )
|
||||
// col 2: (-(c0s0' + c1s1' + c2s2') , c0 , c1 + M, c2 )
|
||||
// col 3: (-(d0s0' + d1s1' + d2s2') , d0 , d1 , d2 + M)
|
||||
(0..self.rows()).for_each(|row_j| {
|
||||
let (tmp_dft_out_data, scratch1) = scratch.tmp_vec_znx_dft(module, self.rank() + 1, self.size());
|
||||
// col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0 , a1 , a2 )
|
||||
// col 1: (-(b0s0 + b1s1 + b2s2) , b0 + M[i], b1 , b2 )
|
||||
// col 2: (-(c0s0 + c1s1 + c2s2) , c0 , c1 + M[i], c2 )
|
||||
// col 3: (-(d0s0 + d1s1 + d2s2) , d0 , d1 , d2 + M[i])
|
||||
|
||||
let mut tmp_dft_out: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
|
||||
data: tmp_dft_out_data,
|
||||
basek: lhs.basek(),
|
||||
k: lhs.k(),
|
||||
};
|
||||
let (mut tmp_dft_i, scratch1) = scratch.tmp_vec_znx_dft(module, cols, tsk.size());
|
||||
{
|
||||
let (mut tmp_dft_col_data, scratch2) = scratch1.tmp_vec_znx_dft(module, 1, self.size());
|
||||
|
||||
{
|
||||
let (tmp_dft_in_data, scratch2) = scratch1.tmp_vec_znx_dft(module, lhs.rank() + 1, lhs.size());
|
||||
|
||||
let mut tmp_dft_in: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
|
||||
data: tmp_dft_in_data,
|
||||
basek: lhs.basek(),
|
||||
k: lhs.k(),
|
||||
};
|
||||
|
||||
// 1) Applies key-switching to GGSW[i][0]: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2)
|
||||
lhs.get_row(module, row_j, 0, &mut tmp_dft_in);
|
||||
// (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
|
||||
tmp_dft_out.keyswitch(module, &tmp_dft_in, ksk, scratch2);
|
||||
self.set_row(module, row_j, 0, &tmp_dft_out);
|
||||
}
|
||||
|
||||
// 2) Isolates IDFT(-(a0s0' + a1s1' + a2s2') + M[i])
|
||||
let (mut tmp_c0_data, scratch2) = scratch1.tmp_vec_znx_big(module, 1, self.size());
|
||||
module.vec_znx_idft_tmp_a(&mut tmp_c0_data, 0, &mut tmp_dft_out, 0);
|
||||
|
||||
// 3) Expands the i-th row of the other columns using the tensor key
|
||||
// col 1: (-(b0s0' + b1s1' + b2s2') , b0 + M[i], b1 , b2 ) = KS_{s0's0', s0's1', s0's2'}(a0) + (0, -(a0s0' + a1s1' + a2s2') + M[i], 0, 0)
|
||||
// col 2: (-(c0s0' + c1s1' + c2s2') , c0 , c1 + M[i], c2 ) = KS_{s1's0', s1's1', s1's2'}(a1) + (0, 0, -(a0s0' + a1s1' + a2s2') + M[i], 0)
|
||||
// col 3: (-(d0s0' + d1s1' + d2s2') , d0 , d1 , d2 + M[i]) = KS_{s2's0', s2's1', s2's2'}(a2) + (0, 0, 0, -(a0s0' + a1s1' + a2s2') + M[i])
|
||||
// Performs a key-switch for each combination of s[i]*s[j], i.e. for a0, a1, a2
|
||||
//
|
||||
// # Example for col=1
|
||||
//
|
||||
// a0 * (-(f0s0 + f1s1 + f1s2) + s0^2, f0, f1, f2) = (-(a0f0s0 + a0f1s1 + a0f1s2) + a0s0^2, a0f0, a0f1, a0f2)
|
||||
// +
|
||||
// a1 * (-(g0s0 + g1s1 + g1s2) + s0s1, g0, g1, g2) = (-(a1g0s0 + a1g1s1 + a1g1s2) + a1s0s1, a1g0, a1g1, a1g2)
|
||||
// +
|
||||
// a2 * (-(h0s0 + h1s1 + h1s2) + s0s2, h0, h1, h2) = (-(a2h0s0 + a2h1s1 + a2h1s2) + a2s0s2, a2h0, a2h1, a2h2)
|
||||
// =
|
||||
// (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0, x1, x2)
|
||||
(1..cols).for_each(|col_i| {
|
||||
let (tmp_dft_i_data, scratch3) = scratch2.tmp_vec_znx_dft(module, cols, tsk.size());
|
||||
let mut tmp_dft_i: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
|
||||
data: tmp_dft_i_data,
|
||||
basek: lhs.basek(),
|
||||
k: lhs.k(),
|
||||
};
|
||||
// Extracts a[i] and multipies with Enc(s[i]s[j])
|
||||
tmp_dft_col_data.extract_column(0, ci_dft, col_i);
|
||||
|
||||
// 5) Performs a key-switch for each combination of s[i]*s[j], i.e. for a0, a1, a2
|
||||
//
|
||||
// # Example for col=1
|
||||
//
|
||||
// a0 * (-(f0s0 + f1s1 + f1s2) + s0^2, f0, f1, f2) = (-(a0f0s0 + a0f1s1 + a0f1s2) + a0s0^2, a0f0, a0f1, a0f2)
|
||||
// +
|
||||
// a1 * (-(g0s0 + g1s1 + g1s2) + s0s1, g0, g1, g2) = (-(a1g0s0 + a1g1s1 + a1g1s2) + a1s0s1, a1g0, a1g1, a1g2)
|
||||
// +
|
||||
// a2 * (-(h0s0 + h1s1 + h1s2) + s0s2, h0, h1, h2) = (-(a2h0s0 + a2h1s1 + a2h1s2) + a2s0s2, a2h0, a2h1, a2h2)
|
||||
// =
|
||||
// (-(x0s0' + x1s1' + x2s2') + s0'(a0s0' + a1s1' + a2s2'), x0, x1, x2)
|
||||
(1..cols).for_each(|col_j| {
|
||||
// Extracts a[i] and multipies with Enc(s'[i]s'[j])
|
||||
let (mut tmp_dft_col_data, scratch4) = scratch3.tmp_vec_znx_dft(module, 1, self.size());
|
||||
tmp_dft_col_data.extract_column(0, &tmp_dft_out.data, col_j);
|
||||
if col_i == 1 {
|
||||
module.vmp_apply(
|
||||
&mut tmp_dft_i,
|
||||
&tmp_dft_col_data,
|
||||
tsk.at(col_i - 1, col_j - 1), // Selects Enc(s[i]s[j])
|
||||
scratch2,
|
||||
);
|
||||
} else {
|
||||
module.vmp_apply_add(
|
||||
&mut tmp_dft_i,
|
||||
&tmp_dft_col_data,
|
||||
tsk.at(col_i - 1, col_j - 1), // Selects Enc(s[i]s[j])
|
||||
scratch2,
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if col_j == 1 {
|
||||
module.vmp_apply(
|
||||
&mut tmp_dft_i,
|
||||
&tmp_dft_col_data,
|
||||
tsk.at(col_i - 1, col_j - 1), // Selects Enc(s'[i]s'[j])
|
||||
scratch4,
|
||||
);
|
||||
} else {
|
||||
module.vmp_apply_add(
|
||||
&mut tmp_dft_i,
|
||||
&tmp_dft_col_data,
|
||||
tsk.at(col_i - 1, col_j - 1), // Selects Enc(s'[i]s'[j])
|
||||
scratch4,
|
||||
);
|
||||
}
|
||||
// Adds -(sum a[i] * s[i]) + m) on the i-th column of tmp_idft_i
|
||||
//
|
||||
// (-(x0s0 + x1s1 + x2s2) + a0s0s0 + a1s0s1 + a2s0s2, x0, x1, x2)
|
||||
// +
|
||||
// (0, -(a0s0 + a1s1 + a2s2) + M[i], 0, 0)
|
||||
// =
|
||||
// (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0 -(a0s0 + a1s1 + a2s2) + M[i], x1, x2)
|
||||
// =
|
||||
// (-(x0s0 + x1s1 + x2s2), x0 + M[i], x1, x2)
|
||||
module.vec_znx_dft_add_inplace(&mut tmp_dft_i, col_j, ci_dft, 0);
|
||||
let (mut tmp_idft, scratch2) = scratch1.tmp_vec_znx_big(module, 1, tsk.size());
|
||||
(0..cols).for_each(|i| {
|
||||
module.vec_znx_idft_tmp_a(&mut tmp_idft, 0, &mut tmp_dft_i, i);
|
||||
module.vec_znx_big_normalize(self.basek(), res, i, &tmp_idft, 0, scratch2);
|
||||
});
|
||||
}
|
||||
|
||||
pub fn keyswitch<DataLhs, DataKsk, DataTsk>(
|
||||
&mut self,
|
||||
module: &Module<FFT64>,
|
||||
lhs: &GGSWCiphertext<DataLhs, FFT64>,
|
||||
ksk: &GLWESwitchingKey<DataKsk, FFT64>,
|
||||
tsk: &TensorKey<DataTsk, FFT64>,
|
||||
scratch: &mut Scratch,
|
||||
) where
|
||||
MatZnxDft<DataLhs, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
MatZnxDft<DataKsk, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
{
|
||||
let cols: usize = self.rank() + 1;
|
||||
|
||||
let (res_data, scratch1) = scratch.tmp_vec_znx(&module, cols, self.size());
|
||||
let mut res: GLWECiphertext<&mut [u8]> = GLWECiphertext::<&mut [u8]> {
|
||||
data: res_data,
|
||||
basek: self.basek(),
|
||||
k: self.k(),
|
||||
};
|
||||
|
||||
let (mut ci_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols, self.size());
|
||||
|
||||
// Keyswitch the j-th row of the col 0
|
||||
(0..lhs.rows()).for_each(|row_i| {
|
||||
// Key-switch column 0, i.e.
|
||||
// col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
|
||||
lhs.keyswitch_internal_col0(module, row_i, &mut res, ksk, scratch2);
|
||||
|
||||
// Isolates DFT(a[i])
|
||||
(0..cols).for_each(|col_i| {
|
||||
module.vec_znx_dft(&mut ci_dft, col_i, &res, col_i);
|
||||
});
|
||||
|
||||
self.set_row(module, row_i, 0, &ci_dft);
|
||||
|
||||
// Generates
|
||||
//
|
||||
// col 1: (-(b0s0' + b1s1' + b2s2') , b0 + M[i], b1 , b2 )
|
||||
// col 2: (-(c0s0' + c1s1' + c2s2') , c0 , c1 + M[i], c2 )
|
||||
// col 3: (-(d0s0' + d1s1' + d2s2') , d0 , d1 , d2 + M[i])
|
||||
(1..cols).for_each(|col_j| {
|
||||
self.expand_row(module, col_j, &mut res, &ci_dft, tsk, scratch2);
|
||||
|
||||
let (mut res_dft, _) = scratch2.tmp_vec_znx_dft(module, cols, self.size());
|
||||
(0..cols).for_each(|i| {
|
||||
module.vec_znx_dft(&mut res_dft, i, &res, i);
|
||||
});
|
||||
|
||||
// Adds -(sum a[i] * s[i]) + m) on the i-th column of tmp_idft_i
|
||||
//
|
||||
// (-(x0s0' + x1s1' + x2s2') + a0s0's0' + a1s0's1' + a2s0's2', x0, x1, x2)
|
||||
// +
|
||||
// (0, -(a0s0' + a1s1' + a2s2') + M[i], 0, 0)
|
||||
// =
|
||||
// (-(x0s0' + x1s1' + x2s2') + s0'(a0s0' + a1s1' + a2s2'), x0 -(a0s0' + a1s1' + a2s2') + M[i], x1, x2)
|
||||
// =
|
||||
// (-(x0s0' + x1s1' + x2s2'), x0 + M[i], x1, x2)
|
||||
{
|
||||
let (mut tmp_idft, scratch3) = scratch3.tmp_vec_znx_big(module, 1, tsk.size());
|
||||
let (mut tmp_znx_small, scratch5) = scratch3.tmp_vec_znx(module, 1, self.size());
|
||||
(0..cols).for_each(|i| {
|
||||
module.vec_znx_idft_tmp_a(&mut tmp_idft, 0, &mut tmp_dft_i, i);
|
||||
if i == col_i {
|
||||
module.vec_znx_big_add_inplace(&mut tmp_idft, 0, &tmp_c0_data, 0);
|
||||
}
|
||||
module.vec_znx_big_normalize(self.basek(), &mut tmp_znx_small, 0, &tmp_idft, 0, scratch5);
|
||||
module.vec_znx_dft(&mut tmp_dft_i, i, &tmp_znx_small, 0);
|
||||
});
|
||||
}
|
||||
|
||||
// Stores (-(x0s0' + x1s1' + x2s2'), x0 + M[i], x1, x2)
|
||||
self.set_row(module, row_j, col_i, &tmp_dft_i);
|
||||
self.set_row(module, row_i, col_j, &res_dft);
|
||||
})
|
||||
})
|
||||
}
|
||||
@@ -542,6 +542,38 @@ where
|
||||
}
|
||||
}
|
||||
|
||||
impl<DataSelf> GGSWCiphertext<DataSelf, FFT64>
|
||||
where
|
||||
MatZnxDft<DataSelf, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
{
|
||||
pub(crate) fn keyswitch_internal_col0<DataRes, DataKsk>(
|
||||
&self,
|
||||
module: &Module<FFT64>,
|
||||
row_i: usize,
|
||||
res: &mut GLWECiphertext<DataRes>,
|
||||
ksk: &GLWESwitchingKey<DataKsk, FFT64>,
|
||||
scratch: &mut Scratch,
|
||||
) where
|
||||
VecZnx<DataRes>: VecZnxToMut + VecZnxToRef,
|
||||
MatZnxDft<DataKsk, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
{
|
||||
#[cfg(debug_assertions)]
|
||||
{
|
||||
assert_eq!(self.rank(), ksk.rank());
|
||||
assert_eq!(res.rank(), ksk.rank());
|
||||
}
|
||||
|
||||
let (tmp_dft_in_data, scratch2) = scratch.tmp_vec_znx_dft(module, self.rank() + 1, self.size());
|
||||
let mut tmp_dft_in: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
|
||||
data: tmp_dft_in_data,
|
||||
basek: self.basek(),
|
||||
k: self.k(),
|
||||
};
|
||||
self.get_row(module, row_i, 0, &mut tmp_dft_in);
|
||||
res.keyswitch_from_fourier(module, &tmp_dft_in, ksk, scratch2);
|
||||
}
|
||||
}
|
||||
|
||||
impl<DataSelf> GetRow<FFT64> for GGSWCiphertext<DataSelf, FFT64>
|
||||
where
|
||||
MatZnxDft<DataSelf, FFT64>: MatZnxDftToRef<FFT64>,
|
||||
|
||||
Reference in New Issue
Block a user