poulpy/core/src/ggsw_ciphertext.rs
core/src/ggsw_ciphertext.rsRaw
1use base2k::{
2 Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx,
3 ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBigAlloc, VecZnxBigOps,
4 VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, VecZnxToMut,
5 VecZnxToRef, ZnxInfos, ZnxZero,
6};
7use sampling::source::Source;
8
9use crate::{
10 automorphism::AutomorphismKey,
11 elem::{GetRow, Infos, SetRow},
12 glwe_ciphertext::GLWECiphertext,
13 glwe_ciphertext_fourier::GLWECiphertextFourier,
14 glwe_plaintext::GLWEPlaintext,
15 keys::SecretKeyFourier,
16 keyswitch_key::GLWESwitchingKey,
17 tensor_key::TensorKey,
18 utils::derive_size,
19};
20
21pub struct GGSWCiphertext<C, B: Backend> {
22 pub data: MatZnxDft<C, B>,
23 pub basek: usize,
24 pub k: usize,
25}
26
27impl<B: Backend> GGSWCiphertext<Vec<u8>, B> {
28 pub fn new(module: &Module<B>, basek: usize, k: usize, rows: usize, rank: usize) -> Self {
29 Self {
30 data: module.new_mat_znx_dft(rows, rank + 1, rank + 1, derive_size(basek, k)),
31 basek: basek,
32 k: k,
33 }
34 }
35}
36
37impl<T, B: Backend> Infos for GGSWCiphertext<T, B> {
38 type Inner = MatZnxDft<T, B>;
39
40 fn inner(&self) -> &Self::Inner {
41 &self.data
42 }
43
44 fn basek(&self) -> usize {
45 self.basek
46 }
47
48 fn k(&self) -> usize {
49 self.k
50 }
51}
52
53impl<T, B: Backend> GGSWCiphertext<T, B> {
54 pub fn rank(&self) -> usize {
55 self.data.cols_out() - 1
56 }
57}
58
59impl<C, B: Backend> MatZnxDftToMut<B> for GGSWCiphertext<C, B>
60where
61 MatZnxDft<C, B>: MatZnxDftToMut<B>,
62{
63 fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> {
64 self.data.to_mut()
65 }
66}
67
68impl<C, B: Backend> MatZnxDftToRef<B> for GGSWCiphertext<C, B>
69where
70 MatZnxDft<C, B>: MatZnxDftToRef<B>,
71{
72 fn to_ref(&self) -> MatZnxDft<&[u8], B> {
73 self.data.to_ref()
74 }
75}
76
77impl GGSWCiphertext<Vec<u8>, FFT64> {
78 pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, rank: usize, size: usize) -> usize {
79 GLWECiphertext::encrypt_sk_scratch_space(module, size)
80 + module.bytes_of_vec_znx(rank + 1, size)
81 + module.bytes_of_vec_znx(1, size)
82 + module.bytes_of_vec_znx_dft(rank + 1, size)
83 }
84
85 pub(crate) fn expand_row_scratch_space(
86 module: &Module<FFT64>,
87 self_size: usize,
88 tensor_key_size: usize,
89 rank: usize,
90 ) -> usize {
91 let tmp_dft_i: usize = module.bytes_of_vec_znx_dft(rank + 1, tensor_key_size);
92 let tmp_dft_col_data: usize = module.bytes_of_vec_znx_dft(1, self_size);
93 let vmp: usize =
94 tmp_dft_col_data + module.vmp_apply_tmp_bytes(self_size, self_size, self_size, rank, rank, tensor_key_size);
95 let tmp_idft: usize = module.bytes_of_vec_znx_big(1, tensor_key_size);
96 let norm: usize = module.vec_znx_big_normalize_tmp_bytes();
97 tmp_dft_i + ((tmp_dft_col_data + vmp) | (tmp_idft + norm))
98 }
99
100 pub(crate) fn keyswitch_internal_col0_scratch_space(
101 module: &Module<FFT64>,
102 out_size: usize,
103 in_size: usize,
104 ksk_size: usize,
105 rank: usize,
106 ) -> usize {
107 GLWECiphertext::keyswitch_from_fourier_scratch_space(module, out_size, rank, in_size, rank, ksk_size)
108 + module.bytes_of_vec_znx_dft(rank + 1, in_size)
109 }
110
111 pub fn keyswitch_scratch_space(
112 module: &Module<FFT64>,
113 out_size: usize,
114 in_size: usize,
115 ksk_size: usize,
116 tensor_key_size: usize,
117 rank: usize,
118 ) -> usize {
119 let res_znx: usize = module.bytes_of_vec_znx(rank + 1, out_size);
120 let ci_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
121 let ks: usize = GGSWCiphertext::keyswitch_internal_col0_scratch_space(module, out_size, in_size, ksk_size, rank);
122 let expand_rows: usize = GGSWCiphertext::expand_row_scratch_space(module, out_size, tensor_key_size, rank);
123 let res_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
124 res_znx + ci_dft + (ks | expand_rows | res_dft)
125 }
126
127 pub fn automorphism_scratch_space(
128 module: &Module<FFT64>,
129 out_size: usize,
130 in_size: usize,
131 auto_key_size: usize,
132 tensor_key_size: usize,
133 rank: usize,
134 ) -> usize {
135 GGSWCiphertext::keyswitch_scratch_space(
136 module,
137 out_size,
138 in_size,
139 auto_key_size,
140 tensor_key_size,
141 rank,
142 )
143 }
144
145 pub fn external_product_scratch_space(
146 module: &Module<FFT64>,
147 out_size: usize,
148 in_size: usize,
149 ggsw_size: usize,
150 rank: usize,
151 ) -> usize {
152 let tmp_in: usize = module.bytes_of_vec_znx_dft(rank + 1, in_size);
153 let tmp_out: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
154 let ggsw: usize = GLWECiphertextFourier::external_product_scratch_space(module, out_size, in_size, ggsw_size, rank);
155 tmp_in + tmp_out + ggsw
156 }
157
158 pub fn external_product_inplace_scratch_space(
159 module: &Module<FFT64>,
160 out_size: usize,
161 ggsw_size: usize,
162 rank: usize,
163 ) -> usize {
164 let tmp: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
165 let ggsw: usize = GLWECiphertextFourier::external_product_inplace_scratch_space(module, out_size, ggsw_size, rank);
166 tmp + ggsw
167 }
168}
169
170impl<DataSelf> GGSWCiphertext<DataSelf, FFT64>
171where
172 MatZnxDft<DataSelf, FFT64>: MatZnxDftToMut<FFT64> + MatZnxDftToRef<FFT64>,
173{
174 pub fn encrypt_sk<DataPt, DataSk>(
175 &mut self,
176 module: &Module<FFT64>,
177 pt: &ScalarZnx<DataPt>,
178 sk_dft: &SecretKeyFourier<DataSk, FFT64>,
179 source_xa: &mut Source,
180 source_xe: &mut Source,
181 sigma: f64,
182 scratch: &mut Scratch,
183 ) where
184 ScalarZnx<DataPt>: ScalarZnxToRef,
185 ScalarZnxDft<DataSk, FFT64>: ScalarZnxDftToRef<FFT64>,
186 {
187 #[cfg(debug_assertions)]
188 {
189 assert_eq!(self.rank(), sk_dft.rank());
190 assert_eq!(self.n(), module.n());
191 assert_eq!(pt.n(), module.n());
192 assert_eq!(sk_dft.n(), module.n());
193 }
194
195 let size: usize = self.size();
196 let basek: usize = self.basek();
197 let k: usize = self.k();
198 let cols: usize = self.rank() + 1;
199
200 let (tmp_znx_pt, scratch_1) = scratch.tmp_vec_znx(module, 1, size);
201 let (tmp_znx_ct, scrach_2) = scratch_1.tmp_vec_znx(module, cols, size);
202
203 let mut vec_znx_pt: GLWEPlaintext<&mut [u8]> = GLWEPlaintext {
204 data: tmp_znx_pt,
205 basek: basek,
206 k: k,
207 };
208
209 let mut vec_znx_ct: GLWECiphertext<&mut [u8]> = GLWECiphertext {
210 data: tmp_znx_ct,
211 basek: basek,
212 k,
213 };
214
215 (0..self.rows()).for_each(|row_i| {
216 vec_znx_pt.data.zero();
217
218 // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
219 module.vec_znx_add_scalar_inplace(&mut vec_znx_pt, 0, row_i, pt, 0);
220 module.vec_znx_normalize_inplace(basek, &mut vec_znx_pt, 0, scrach_2);
221
222 (0..cols).for_each(|col_j| {
223 // rlwe encrypt of vec_znx_pt into vec_znx_ct
224
225 vec_znx_ct.encrypt_sk_private(
226 module,
227 Some((&vec_znx_pt, col_j)),
228 sk_dft,
229 source_xa,
230 source_xe,
231 sigma,
232 scrach_2,
233 );
234
235 // Switch vec_znx_ct into DFT domain
236 {
237 let (mut vec_znx_dft_ct, _) = scrach_2.tmp_vec_znx_dft(module, cols, size);
238
239 (0..cols).for_each(|i| {
240 module.vec_znx_dft(&mut vec_znx_dft_ct, i, &vec_znx_ct, i);
241 });
242
243 self.set_row(module, row_i, col_j, &vec_znx_dft_ct);
244 }
245 });
246 });
247 }
248
249 pub(crate) fn expand_row<R, DataCi, DataTsk>(
250 &mut self,
251 module: &Module<FFT64>,
252 col_j: usize,
253 res: &mut R,
254 ci_dft: &VecZnxDft<DataCi, FFT64>,
255 tsk: &TensorKey<DataTsk, FFT64>,
256 scratch: &mut Scratch,
257 ) where
258 R: VecZnxToMut,
259 VecZnxDft<DataCi, FFT64>: VecZnxDftToRef<FFT64>,
260 MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
261 {
262 let cols: usize = self.rank() + 1;
263
264 // Example for rank 3:
265 //
266 // Note: M is a vector (m, Bm, B^2m, B^3m, ...), so each column is
267 // actually composed of that many rows and we focus on a specific row here
268 // implicitely given ci_dft.
269 //
270 // # Input
271 //
272 // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0 , a1 , a2 )
273 // col 1: (0, 0, 0, 0)
274 // col 2: (0, 0, 0, 0)
275 // col 3: (0, 0, 0, 0)
276 //
277 // # Output
278 //
279 // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0 , a1 , a2 )
280 // col 1: (-(b0s0 + b1s1 + b2s2) , b0 + M[i], b1 , b2 )
281 // col 2: (-(c0s0 + c1s1 + c2s2) , c0 , c1 + M[i], c2 )
282 // col 3: (-(d0s0 + d1s1 + d2s2) , d0 , d1 , d2 + M[i])
283
284 let (mut tmp_dft_i, scratch1) = scratch.tmp_vec_znx_dft(module, cols, tsk.size());
285 {
286 let (mut tmp_dft_col_data, scratch2) = scratch1.tmp_vec_znx_dft(module, 1, self.size());
287
288 // Performs a key-switch for each combination of s[i]*s[j], i.e. for a0, a1, a2
289 //
290 // # Example for col=1
291 //
292 // a0 * (-(f0s0 + f1s1 + f1s2) + s0^2, f0, f1, f2) = (-(a0f0s0 + a0f1s1 + a0f1s2) + a0s0^2, a0f0, a0f1, a0f2)
293 // +
294 // a1 * (-(g0s0 + g1s1 + g1s2) + s0s1, g0, g1, g2) = (-(a1g0s0 + a1g1s1 + a1g1s2) + a1s0s1, a1g0, a1g1, a1g2)
295 // +
296 // a2 * (-(h0s0 + h1s1 + h1s2) + s0s2, h0, h1, h2) = (-(a2h0s0 + a2h1s1 + a2h1s2) + a2s0s2, a2h0, a2h1, a2h2)
297 // =
298 // (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0, x1, x2)
299 (1..cols).for_each(|col_i| {
300 // Extracts a[i] and multipies with Enc(s[i]s[j])
301 tmp_dft_col_data.extract_column(0, ci_dft, col_i);
302
303 if col_i == 1 {
304 module.vmp_apply(
305 &mut tmp_dft_i,
306 &tmp_dft_col_data,
307 tsk.at(col_i - 1, col_j - 1), // Selects Enc(s[i]s[j])
308 scratch2,
309 );
310 } else {
311 module.vmp_apply_add(
312 &mut tmp_dft_i,
313 &tmp_dft_col_data,
314 tsk.at(col_i - 1, col_j - 1), // Selects Enc(s[i]s[j])
315 scratch2,
316 );
317 }
318 });
319 }
320
321 // Adds -(sum a[i] * s[i]) + m) on the i-th column of tmp_idft_i
322 //
323 // (-(x0s0 + x1s1 + x2s2) + a0s0s0 + a1s0s1 + a2s0s2, x0, x1, x2)
324 // +
325 // (0, -(a0s0 + a1s1 + a2s2) + M[i], 0, 0)
326 // =
327 // (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0 -(a0s0 + a1s1 + a2s2) + M[i], x1, x2)
328 // =
329 // (-(x0s0 + x1s1 + x2s2), x0 + M[i], x1, x2)
330 module.vec_znx_dft_add_inplace(&mut tmp_dft_i, col_j, ci_dft, 0);
331 let (mut tmp_idft, scratch2) = scratch1.tmp_vec_znx_big(module, 1, tsk.size());
332 (0..cols).for_each(|i| {
333 module.vec_znx_idft_tmp_a(&mut tmp_idft, 0, &mut tmp_dft_i, i);
334 module.vec_znx_big_normalize(self.basek(), res, i, &tmp_idft, 0, scratch2);
335 });
336 }
337
338 pub fn keyswitch<DataLhs, DataKsk, DataTsk>(
339 &mut self,
340 module: &Module<FFT64>,
341 lhs: &GGSWCiphertext<DataLhs, FFT64>,
342 ksk: &GLWESwitchingKey<DataKsk, FFT64>,
343 tsk: &TensorKey<DataTsk, FFT64>,
344 scratch: &mut Scratch,
345 ) where
346 MatZnxDft<DataLhs, FFT64>: MatZnxDftToRef<FFT64>,
347 MatZnxDft<DataKsk, FFT64>: MatZnxDftToRef<FFT64>,
348 MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
349 {
350 let cols: usize = self.rank() + 1;
351
352 let (res_data, scratch1) = scratch.tmp_vec_znx(&module, cols, self.size());
353 let mut res: GLWECiphertext<&mut [u8]> = GLWECiphertext::<&mut [u8]> {
354 data: res_data,
355 basek: self.basek(),
356 k: self.k(),
357 };
358
359 let (mut ci_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols, self.size());
360
361 // Keyswitch the j-th row of the col 0
362 (0..lhs.rows()).for_each(|row_i| {
363 // Key-switch column 0, i.e.
364 // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
365 lhs.keyswitch_internal_col0(module, row_i, &mut res, ksk, scratch2);
366
367 // Isolates DFT(a[i])
368 (0..cols).for_each(|col_i| {
369 module.vec_znx_dft(&mut ci_dft, col_i, &res, col_i);
370 });
371
372 self.set_row(module, row_i, 0, &ci_dft);
373
374 // Generates
375 //
376 // col 1: (-(b0s0' + b1s1' + b2s2') , b0 + M[i], b1 , b2 )
377 // col 2: (-(c0s0' + c1s1' + c2s2') , c0 , c1 + M[i], c2 )
378 // col 3: (-(d0s0' + d1s1' + d2s2') , d0 , d1 , d2 + M[i])
379 (1..cols).for_each(|col_j| {
380 self.expand_row(module, col_j, &mut res, &ci_dft, tsk, scratch2);
381
382 let (mut res_dft, _) = scratch2.tmp_vec_znx_dft(module, cols, self.size());
383 (0..cols).for_each(|i| {
384 module.vec_znx_dft(&mut res_dft, i, &res, i);
385 });
386
387 self.set_row(module, row_i, col_j, &res_dft);
388 })
389 })
390 }
391
392 pub fn automorphism<DataLhs, DataAk, DataTsk>(
393 &mut self,
394 module: &Module<FFT64>,
395 lhs: &GGSWCiphertext<DataLhs, FFT64>,
396 auto_key: &AutomorphismKey<DataAk, FFT64>,
397 tensor_key: &TensorKey<DataTsk, FFT64>,
398 scratch: &mut Scratch,
399 ) where
400 MatZnxDft<DataLhs, FFT64>: MatZnxDftToRef<FFT64>,
401 MatZnxDft<DataAk, FFT64>: MatZnxDftToRef<FFT64>,
402 MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
403 {
404 #[cfg(debug_assertions)]
405 {
406 assert_eq!(
407 self.rank(),
408 lhs.rank(),
409 "ggsw_out rank: {} != ggsw_in rank: {}",
410 self.rank(),
411 lhs.rank()
412 );
413 assert_eq!(
414 self.rank(),
415 auto_key.rank(),
416 "ggsw_in rank: {} != auto_key rank: {}",
417 self.rank(),
418 auto_key.rank()
419 );
420 assert_eq!(
421 self.rank(),
422 tensor_key.rank(),
423 "ggsw_in rank: {} != tensor_key rank: {}",
424 self.rank(),
425 tensor_key.rank()
426 );
427 };
428
429 let cols: usize = self.rank() + 1;
430
431 let (res_data, scratch1) = scratch.tmp_vec_znx(&module, cols, self.size());
432 let mut res: GLWECiphertext<&mut [u8]> = GLWECiphertext::<&mut [u8]> {
433 data: res_data,
434 basek: self.basek(),
435 k: self.k(),
436 };
437
438 let (mut ci_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols, self.size());
439
440 // Keyswitch the j-th row of the col 0
441 (0..lhs.rows()).for_each(|row_i| {
442 // Key-switch column 0, i.e.
443 // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2)
444 lhs.keyswitch_internal_col0(module, row_i, &mut res, &auto_key.key, scratch2);
445
446 // Isolates DFT(AUTO(a[i]))
447 (0..cols).for_each(|col_i| {
448 // (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2) -> (-(a0s0 + a1s1 + a2s2) + pi(M[i]), a0, a1, a2)
449 module.vec_znx_automorphism_inplace(auto_key.p(), &mut res, col_i);
450 module.vec_znx_dft(&mut ci_dft, col_i, &res, col_i);
451 });
452
453 self.set_row(module, row_i, 0, &ci_dft);
454
455 // Generates
456 //
457 // col 1: (-(b0s0 + b1s1 + b2s2) , b0 + pi(M[i]), b1 , b2 )
458 // col 2: (-(c0s0 + c1s1 + c2s2) , c0 , c1 + pi(M[i]), c2 )
459 // col 3: (-(d0s0 + d1s1 + d2s2) , d0 , d1 , d2 + pi(M[i]))
460 (1..cols).for_each(|col_j| {
461 self.expand_row(module, col_j, &mut res, &ci_dft, tensor_key, scratch2);
462
463 let (mut res_dft, _) = scratch2.tmp_vec_znx_dft(module, cols, self.size());
464 (0..cols).for_each(|i| {
465 module.vec_znx_dft(&mut res_dft, i, &res, i);
466 });
467
468 self.set_row(module, row_i, col_j, &res_dft);
469 })
470 })
471 }
472
473 pub fn external_product<DataLhs, DataRhs>(
474 &mut self,
475 module: &Module<FFT64>,
476 lhs: &GGSWCiphertext<DataLhs, FFT64>,
477 rhs: &GGSWCiphertext<DataRhs, FFT64>,
478 scratch: &mut Scratch,
479 ) where
480 MatZnxDft<DataLhs, FFT64>: MatZnxDftToRef<FFT64>,
481 MatZnxDft<DataRhs, FFT64>: MatZnxDftToRef<FFT64>,
482 {
483 #[cfg(debug_assertions)]
484 {
485 assert_eq!(
486 self.rank(),
487 lhs.rank(),
488 "ggsw_out rank: {} != ggsw_in rank: {}",
489 self.rank(),
490 lhs.rank()
491 );
492 assert_eq!(
493 self.rank(),
494 rhs.rank(),
495 "ggsw_in rank: {} != ggsw_apply rank: {}",
496 self.rank(),
497 rhs.rank()
498 );
499 }
500
501 let (tmp_in_data, scratch1) = scratch.tmp_vec_znx_dft(module, lhs.rank() + 1, lhs.size());
502
503 let mut tmp_in: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
504 data: tmp_in_data,
505 basek: lhs.basek(),
506 k: lhs.k(),
507 };
508
509 let (tmp_out_data, scratch2) = scratch1.tmp_vec_znx_dft(module, self.rank() + 1, self.size());
510
511 let mut tmp_out: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
512 data: tmp_out_data,
513 basek: self.basek(),
514 k: self.k(),
515 };
516
517 (0..self.rank() + 1).for_each(|col_i| {
518 (0..self.rows()).for_each(|row_j| {
519 lhs.get_row(module, row_j, col_i, &mut tmp_in);
520 tmp_out.external_product(module, &tmp_in, rhs, scratch2);
521 self.set_row(module, row_j, col_i, &tmp_out);
522 });
523 });
524
525 tmp_out.data.zero();
526
527 (self.rows().min(lhs.rows())..self.rows()).for_each(|row_i| {
528 (0..self.rank() + 1).for_each(|col_j| {
529 self.set_row(module, row_i, col_j, &tmp_out);
530 });
531 });
532 }
533
534 pub fn external_product_inplace<DataRhs>(
535 &mut self,
536 module: &Module<FFT64>,
537 rhs: &GGSWCiphertext<DataRhs, FFT64>,
538 scratch: &mut Scratch,
539 ) where
540 MatZnxDft<DataRhs, FFT64>: MatZnxDftToRef<FFT64>,
541 {
542 #[cfg(debug_assertions)]
543 {
544 assert_eq!(
545 self.rank(),
546 rhs.rank(),
547 "ggsw_out rank: {} != ggsw_apply: {}",
548 self.rank(),
549 rhs.rank()
550 );
551 }
552
553 let (tmp_data, scratch1) = scratch.tmp_vec_znx_dft(module, self.rank() + 1, self.size());
554
555 let mut tmp: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
556 data: tmp_data,
557 basek: self.basek(),
558 k: self.k(),
559 };
560
561 (0..self.rank() + 1).for_each(|col_i| {
562 (0..self.rows()).for_each(|row_j| {
563 self.get_row(module, row_j, col_i, &mut tmp);
564 tmp.external_product_inplace(module, rhs, scratch1);
565 self.set_row(module, row_j, col_i, &tmp);
566 });
567 });
568 }
569}
570
571impl<DataSelf> GGSWCiphertext<DataSelf, FFT64>
572where
573 MatZnxDft<DataSelf, FFT64>: MatZnxDftToRef<FFT64>,
574{
575 pub(crate) fn keyswitch_internal_col0<DataRes, DataKsk>(
576 &self,
577 module: &Module<FFT64>,
578 row_i: usize,
579 res: &mut GLWECiphertext<DataRes>,
580 ksk: &GLWESwitchingKey<DataKsk, FFT64>,
581 scratch: &mut Scratch,
582 ) where
583 VecZnx<DataRes>: VecZnxToMut + VecZnxToRef,
584 MatZnxDft<DataKsk, FFT64>: MatZnxDftToRef<FFT64>,
585 {
586 #[cfg(debug_assertions)]
587 {
588 assert_eq!(self.rank(), ksk.rank());
589 assert_eq!(res.rank(), ksk.rank());
590 }
591
592 let (tmp_dft_in_data, scratch2) = scratch.tmp_vec_znx_dft(module, self.rank() + 1, self.size());
593 let mut tmp_dft_in: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
594 data: tmp_dft_in_data,
595 basek: self.basek(),
596 k: self.k(),
597 };
598 self.get_row(module, row_i, 0, &mut tmp_dft_in);
599 res.keyswitch_from_fourier(module, &tmp_dft_in, ksk, scratch2);
600 }
601}
602
603impl<DataSelf> GetRow<FFT64> for GGSWCiphertext<DataSelf, FFT64>
604where
605 MatZnxDft<DataSelf, FFT64>: MatZnxDftToRef<FFT64>,
606{
607 fn get_row<R>(&self, module: &Module<FFT64>, row_i: usize, col_j: usize, res: &mut R)
608 where
609 R: VecZnxDftToMut<FFT64>,
610 {
611 module.vmp_extract_row(res, self, row_i, col_j);
612 }
613}
614
615impl<DataSelf> SetRow<FFT64> for GGSWCiphertext<DataSelf, FFT64>
616where
617 MatZnxDft<DataSelf, FFT64>: MatZnxDftToMut<FFT64>,
618{
619 fn set_row<R>(&mut self, module: &Module<FFT64>, row_i: usize, col_j: usize, a: &R)
620 where
621 R: VecZnxDftToRef<FFT64>,
622 {
623 module.vmp_prepare_row(self, row_i, col_j, a);
624 }
625}