poulpy/core/src/ggsw_ciphertext.rs
core/src/ggsw_ciphertext.rsRaw
1use backend::{
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, ZnxInfos,
5 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 alloc(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 keyswitch_inplace_scratch_space(
128 module: &Module<FFT64>,
129 out_size: usize,
130 ksk_size: usize,
131 tensor_key_size: usize,
132 rank: usize,
133 ) -> usize {
134 GGSWCiphertext::keyswitch_scratch_space(module, out_size, out_size, ksk_size, tensor_key_size, rank)
135 }
136
137 pub fn automorphism_scratch_space(
138 module: &Module<FFT64>,
139 out_size: usize,
140 in_size: usize,
141 auto_key_size: usize,
142 tensor_key_size: usize,
143 rank: usize,
144 ) -> usize {
145 GGSWCiphertext::keyswitch_scratch_space(
146 module,
147 out_size,
148 in_size,
149 auto_key_size,
150 tensor_key_size,
151 rank,
152 )
153 }
154
155 pub fn automorphism_inplace_scratch_space(
156 module: &Module<FFT64>,
157 out_size: usize,
158 auto_key_size: usize,
159 tensor_key_size: usize,
160 rank: usize,
161 ) -> usize {
162 GGSWCiphertext::automorphism_scratch_space(
163 module,
164 out_size,
165 out_size,
166 auto_key_size,
167 tensor_key_size,
168 rank,
169 )
170 }
171
172 pub fn external_product_scratch_space(
173 module: &Module<FFT64>,
174 out_size: usize,
175 in_size: usize,
176 ggsw_size: usize,
177 rank: usize,
178 ) -> usize {
179 let tmp_in: usize = module.bytes_of_vec_znx_dft(rank + 1, in_size);
180 let tmp_out: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
181 let ggsw: usize = GLWECiphertextFourier::external_product_scratch_space(module, out_size, in_size, ggsw_size, rank);
182 tmp_in + tmp_out + ggsw
183 }
184
185 pub fn external_product_inplace_scratch_space(
186 module: &Module<FFT64>,
187 out_size: usize,
188 ggsw_size: usize,
189 rank: usize,
190 ) -> usize {
191 let tmp: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
192 let ggsw: usize = GLWECiphertextFourier::external_product_inplace_scratch_space(module, out_size, ggsw_size, rank);
193 tmp + ggsw
194 }
195}
196
197impl<DataSelf> GGSWCiphertext<DataSelf, FFT64>
198where
199 MatZnxDft<DataSelf, FFT64>: MatZnxDftToMut<FFT64>,
200{
201 pub fn encrypt_sk<DataPt, DataSk>(
202 &mut self,
203 module: &Module<FFT64>,
204 pt: &ScalarZnx<DataPt>,
205 sk_dft: &SecretKeyFourier<DataSk, FFT64>,
206 source_xa: &mut Source,
207 source_xe: &mut Source,
208 sigma: f64,
209 scratch: &mut Scratch,
210 ) where
211 ScalarZnx<DataPt>: ScalarZnxToRef,
212 ScalarZnxDft<DataSk, FFT64>: ScalarZnxDftToRef<FFT64>,
213 {
214 #[cfg(debug_assertions)]
215 {
216 assert_eq!(self.rank(), sk_dft.rank());
217 assert_eq!(self.n(), module.n());
218 assert_eq!(pt.n(), module.n());
219 assert_eq!(sk_dft.n(), module.n());
220 }
221
222 let size: usize = self.size();
223 let basek: usize = self.basek();
224 let k: usize = self.k();
225 let cols: usize = self.rank() + 1;
226
227 let (tmp_znx_pt, scratch_1) = scratch.tmp_vec_znx(module, 1, size);
228 let (tmp_znx_ct, scrach_2) = scratch_1.tmp_vec_znx(module, cols, size);
229
230 let mut vec_znx_pt: GLWEPlaintext<&mut [u8]> = GLWEPlaintext {
231 data: tmp_znx_pt,
232 basek: basek,
233 k: k,
234 };
235
236 let mut vec_znx_ct: GLWECiphertext<&mut [u8]> = GLWECiphertext {
237 data: tmp_znx_ct,
238 basek: basek,
239 k,
240 };
241
242 (0..self.rows()).for_each(|row_i| {
243 vec_znx_pt.data.zero();
244
245 // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
246 module.vec_znx_add_scalar_inplace(&mut vec_znx_pt, 0, row_i, pt, 0);
247 module.vec_znx_normalize_inplace(basek, &mut vec_znx_pt, 0, scrach_2);
248
249 (0..cols).for_each(|col_j| {
250 // rlwe encrypt of vec_znx_pt into vec_znx_ct
251
252 vec_znx_ct.encrypt_sk_private(
253 module,
254 Some((&vec_znx_pt, col_j)),
255 sk_dft,
256 source_xa,
257 source_xe,
258 sigma,
259 scrach_2,
260 );
261
262 // Switch vec_znx_ct into DFT domain
263 {
264 let (mut vec_znx_dft_ct, _) = scrach_2.tmp_vec_znx_dft(module, cols, size);
265
266 (0..cols).for_each(|i| {
267 module.vec_znx_dft(&mut vec_znx_dft_ct, i, &vec_znx_ct, i);
268 });
269
270 self.set_row(module, row_i, col_j, &vec_znx_dft_ct);
271 }
272 });
273 });
274 }
275
276 pub(crate) fn expand_row<R, DataCi, DataTsk>(
277 &mut self,
278 module: &Module<FFT64>,
279 col_j: usize,
280 res: &mut R,
281 ci_dft: &VecZnxDft<DataCi, FFT64>,
282 tsk: &TensorKey<DataTsk, FFT64>,
283 scratch: &mut Scratch,
284 ) where
285 R: VecZnxToMut,
286 VecZnxDft<DataCi, FFT64>: VecZnxDftToRef<FFT64>,
287 MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
288 {
289 let cols: usize = self.rank() + 1;
290
291 // Example for rank 3:
292 //
293 // Note: M is a vector (m, Bm, B^2m, B^3m, ...), so each column is
294 // actually composed of that many rows and we focus on a specific row here
295 // implicitely given ci_dft.
296 //
297 // # Input
298 //
299 // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0 , a1 , a2 )
300 // col 1: (0, 0, 0, 0)
301 // col 2: (0, 0, 0, 0)
302 // col 3: (0, 0, 0, 0)
303 //
304 // # Output
305 //
306 // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0 , a1 , a2 )
307 // col 1: (-(b0s0 + b1s1 + b2s2) , b0 + M[i], b1 , b2 )
308 // col 2: (-(c0s0 + c1s1 + c2s2) , c0 , c1 + M[i], c2 )
309 // col 3: (-(d0s0 + d1s1 + d2s2) , d0 , d1 , d2 + M[i])
310
311 let (mut tmp_dft_i, scratch1) = scratch.tmp_vec_znx_dft(module, cols, tsk.size());
312 {
313 let (mut tmp_dft_col_data, scratch2) = scratch1.tmp_vec_znx_dft(module, 1, self.size());
314
315 // Performs a key-switch for each combination of s[i]*s[j], i.e. for a0, a1, a2
316 //
317 // # Example for col=1
318 //
319 // a0 * (-(f0s0 + f1s1 + f1s2) + s0^2, f0, f1, f2) = (-(a0f0s0 + a0f1s1 + a0f1s2) + a0s0^2, a0f0, a0f1, a0f2)
320 // +
321 // a1 * (-(g0s0 + g1s1 + g1s2) + s0s1, g0, g1, g2) = (-(a1g0s0 + a1g1s1 + a1g1s2) + a1s0s1, a1g0, a1g1, a1g2)
322 // +
323 // a2 * (-(h0s0 + h1s1 + h1s2) + s0s2, h0, h1, h2) = (-(a2h0s0 + a2h1s1 + a2h1s2) + a2s0s2, a2h0, a2h1, a2h2)
324 // =
325 // (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0, x1, x2)
326 (1..cols).for_each(|col_i| {
327 // Extracts a[i] and multipies with Enc(s[i]s[j])
328 tmp_dft_col_data.extract_column(0, ci_dft, col_i);
329
330 if col_i == 1 {
331 module.vmp_apply(
332 &mut tmp_dft_i,
333 &tmp_dft_col_data,
334 tsk.at(col_i - 1, col_j - 1), // Selects Enc(s[i]s[j])
335 scratch2,
336 );
337 } else {
338 module.vmp_apply_add(
339 &mut tmp_dft_i,
340 &tmp_dft_col_data,
341 tsk.at(col_i - 1, col_j - 1), // Selects Enc(s[i]s[j])
342 scratch2,
343 );
344 }
345 });
346 }
347
348 // Adds -(sum a[i] * s[i]) + m) on the i-th column of tmp_idft_i
349 //
350 // (-(x0s0 + x1s1 + x2s2) + a0s0s0 + a1s0s1 + a2s0s2, x0, x1, x2)
351 // +
352 // (0, -(a0s0 + a1s1 + a2s2) + M[i], 0, 0)
353 // =
354 // (-(x0s0 + x1s1 + x2s2) + s0(a0s0 + a1s1 + a2s2), x0 -(a0s0 + a1s1 + a2s2) + M[i], x1, x2)
355 // =
356 // (-(x0s0 + x1s1 + x2s2), x0 + M[i], x1, x2)
357 module.vec_znx_dft_add_inplace(&mut tmp_dft_i, col_j, ci_dft, 0);
358 let (mut tmp_idft, scratch2) = scratch1.tmp_vec_znx_big(module, 1, tsk.size());
359 (0..cols).for_each(|i| {
360 module.vec_znx_idft_tmp_a(&mut tmp_idft, 0, &mut tmp_dft_i, i);
361 module.vec_znx_big_normalize(self.basek(), res, i, &tmp_idft, 0, scratch2);
362 });
363 }
364
365 pub fn keyswitch<DataLhs, DataKsk, DataTsk>(
366 &mut self,
367 module: &Module<FFT64>,
368 lhs: &GGSWCiphertext<DataLhs, FFT64>,
369 ksk: &GLWESwitchingKey<DataKsk, FFT64>,
370 tsk: &TensorKey<DataTsk, FFT64>,
371 scratch: &mut Scratch,
372 ) where
373 MatZnxDft<DataLhs, FFT64>: MatZnxDftToRef<FFT64>,
374 MatZnxDft<DataKsk, FFT64>: MatZnxDftToRef<FFT64>,
375 MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
376 {
377 let cols: usize = self.rank() + 1;
378
379 let (res_data, scratch1) = scratch.tmp_vec_znx(&module, cols, self.size());
380 let mut res: GLWECiphertext<&mut [u8]> = GLWECiphertext::<&mut [u8]> {
381 data: res_data,
382 basek: self.basek(),
383 k: self.k(),
384 };
385
386 let (mut ci_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols, self.size());
387
388 // Keyswitch the j-th row of the col 0
389 (0..lhs.rows()).for_each(|row_i| {
390 // Key-switch column 0, i.e.
391 // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0s0' + a1s1' + a2s2') + M[i], a0, a1, a2)
392 lhs.keyswitch_internal_col0(module, row_i, &mut res, ksk, scratch2);
393
394 // Isolates DFT(a[i])
395 (0..cols).for_each(|col_i| {
396 module.vec_znx_dft(&mut ci_dft, col_i, &res, col_i);
397 });
398
399 self.set_row(module, row_i, 0, &ci_dft);
400
401 // Generates
402 //
403 // col 1: (-(b0s0' + b1s1' + b2s2') , b0 + M[i], b1 , b2 )
404 // col 2: (-(c0s0' + c1s1' + c2s2') , c0 , c1 + M[i], c2 )
405 // col 3: (-(d0s0' + d1s1' + d2s2') , d0 , d1 , d2 + M[i])
406 (1..cols).for_each(|col_j| {
407 self.expand_row(module, col_j, &mut res, &ci_dft, tsk, scratch2);
408
409 let (mut res_dft, _) = scratch2.tmp_vec_znx_dft(module, cols, self.size());
410 (0..cols).for_each(|i| {
411 module.vec_znx_dft(&mut res_dft, i, &res, i);
412 });
413
414 self.set_row(module, row_i, col_j, &res_dft);
415 })
416 })
417 }
418
419 pub fn keyswitch_inplace<DataKsk, DataTsk>(
420 &mut self,
421 module: &Module<FFT64>,
422 ksk: &GLWESwitchingKey<DataKsk, FFT64>,
423 tsk: &TensorKey<DataTsk, FFT64>,
424 scratch: &mut Scratch,
425 ) where
426 MatZnxDft<DataKsk, FFT64>: MatZnxDftToRef<FFT64>,
427 MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
428 {
429 unsafe {
430 let self_ptr: *mut GGSWCiphertext<DataSelf, FFT64> = self as *mut GGSWCiphertext<DataSelf, FFT64>;
431 self.keyswitch(module, &*self_ptr, ksk, tsk, scratch);
432 }
433 }
434
435 pub fn automorphism<DataLhs, DataAk, DataTsk>(
436 &mut self,
437 module: &Module<FFT64>,
438 lhs: &GGSWCiphertext<DataLhs, FFT64>,
439 auto_key: &AutomorphismKey<DataAk, FFT64>,
440 tensor_key: &TensorKey<DataTsk, FFT64>,
441 scratch: &mut Scratch,
442 ) where
443 MatZnxDft<DataLhs, FFT64>: MatZnxDftToRef<FFT64>,
444 MatZnxDft<DataAk, FFT64>: MatZnxDftToRef<FFT64>,
445 MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
446 {
447 #[cfg(debug_assertions)]
448 {
449 assert_eq!(
450 self.rank(),
451 lhs.rank(),
452 "ggsw_out rank: {} != ggsw_in rank: {}",
453 self.rank(),
454 lhs.rank()
455 );
456 assert_eq!(
457 self.rank(),
458 auto_key.rank(),
459 "ggsw_in rank: {} != auto_key rank: {}",
460 self.rank(),
461 auto_key.rank()
462 );
463 assert_eq!(
464 self.rank(),
465 tensor_key.rank(),
466 "ggsw_in rank: {} != tensor_key rank: {}",
467 self.rank(),
468 tensor_key.rank()
469 );
470 };
471
472 let cols: usize = self.rank() + 1;
473
474 let (res_data, scratch1) = scratch.tmp_vec_znx(&module, cols, self.size());
475 let mut res: GLWECiphertext<&mut [u8]> = GLWECiphertext::<&mut [u8]> {
476 data: res_data,
477 basek: self.basek(),
478 k: self.k(),
479 };
480
481 let (mut ci_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols, self.size());
482
483 // Keyswitch the j-th row of the col 0
484 (0..lhs.rows()).for_each(|row_i| {
485 // Key-switch column 0, i.e.
486 // col 0: (-(a0s0 + a1s1 + a2s2) + M[i], a0, a1, a2) -> (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2)
487 lhs.keyswitch_internal_col0(module, row_i, &mut res, &auto_key.key, scratch2);
488
489 // Isolates DFT(AUTO(a[i]))
490 (0..cols).for_each(|col_i| {
491 // (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2) -> (-(a0s0 + a1s1 + a2s2) + pi(M[i]), a0, a1, a2)
492 module.vec_znx_automorphism_inplace(auto_key.p(), &mut res, col_i);
493 module.vec_znx_dft(&mut ci_dft, col_i, &res, col_i);
494 });
495
496 self.set_row(module, row_i, 0, &ci_dft);
497
498 // Generates
499 //
500 // col 1: (-(b0s0 + b1s1 + b2s2) , b0 + pi(M[i]), b1 , b2 )
501 // col 2: (-(c0s0 + c1s1 + c2s2) , c0 , c1 + pi(M[i]), c2 )
502 // col 3: (-(d0s0 + d1s1 + d2s2) , d0 , d1 , d2 + pi(M[i]))
503 (1..cols).for_each(|col_j| {
504 self.expand_row(module, col_j, &mut res, &ci_dft, tensor_key, scratch2);
505
506 let (mut res_dft, _) = scratch2.tmp_vec_znx_dft(module, cols, self.size());
507 (0..cols).for_each(|i| {
508 module.vec_znx_dft(&mut res_dft, i, &res, i);
509 });
510
511 self.set_row(module, row_i, col_j, &res_dft);
512 })
513 })
514 }
515
516 pub fn automorphism_inplace<DataKsk, DataTsk>(
517 &mut self,
518 module: &Module<FFT64>,
519 auto_key: &AutomorphismKey<DataKsk, FFT64>,
520 tensor_key: &TensorKey<DataTsk, FFT64>,
521 scratch: &mut Scratch,
522 ) where
523 MatZnxDft<DataKsk, FFT64>: MatZnxDftToRef<FFT64>,
524 MatZnxDft<DataTsk, FFT64>: MatZnxDftToRef<FFT64>,
525 {
526 unsafe {
527 let self_ptr: *mut GGSWCiphertext<DataSelf, FFT64> = self as *mut GGSWCiphertext<DataSelf, FFT64>;
528 self.automorphism(module, &*self_ptr, auto_key, tensor_key, scratch);
529 }
530 }
531
532 pub fn external_product<DataLhs, DataRhs>(
533 &mut self,
534 module: &Module<FFT64>,
535 lhs: &GGSWCiphertext<DataLhs, FFT64>,
536 rhs: &GGSWCiphertext<DataRhs, FFT64>,
537 scratch: &mut Scratch,
538 ) where
539 MatZnxDft<DataLhs, FFT64>: MatZnxDftToRef<FFT64>,
540 MatZnxDft<DataRhs, FFT64>: MatZnxDftToRef<FFT64>,
541 {
542 #[cfg(debug_assertions)]
543 {
544 assert_eq!(
545 self.rank(),
546 lhs.rank(),
547 "ggsw_out rank: {} != ggsw_in rank: {}",
548 self.rank(),
549 lhs.rank()
550 );
551 assert_eq!(
552 self.rank(),
553 rhs.rank(),
554 "ggsw_in rank: {} != ggsw_apply rank: {}",
555 self.rank(),
556 rhs.rank()
557 );
558 }
559
560 let (tmp_in_data, scratch1) = scratch.tmp_vec_znx_dft(module, lhs.rank() + 1, lhs.size());
561
562 let mut tmp_in: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
563 data: tmp_in_data,
564 basek: lhs.basek(),
565 k: lhs.k(),
566 };
567
568 let (tmp_out_data, scratch2) = scratch1.tmp_vec_znx_dft(module, self.rank() + 1, self.size());
569
570 let mut tmp_out: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
571 data: tmp_out_data,
572 basek: self.basek(),
573 k: self.k(),
574 };
575
576 (0..self.rank() + 1).for_each(|col_i| {
577 (0..self.rows()).for_each(|row_j| {
578 lhs.get_row(module, row_j, col_i, &mut tmp_in);
579 tmp_out.external_product(module, &tmp_in, rhs, scratch2);
580 self.set_row(module, row_j, col_i, &tmp_out);
581 });
582 });
583
584 tmp_out.data.zero();
585
586 (self.rows().min(lhs.rows())..self.rows()).for_each(|row_i| {
587 (0..self.rank() + 1).for_each(|col_j| {
588 self.set_row(module, row_i, col_j, &tmp_out);
589 });
590 });
591 }
592
593 pub fn external_product_inplace<DataRhs>(
594 &mut self,
595 module: &Module<FFT64>,
596 rhs: &GGSWCiphertext<DataRhs, FFT64>,
597 scratch: &mut Scratch,
598 ) where
599 MatZnxDft<DataRhs, FFT64>: MatZnxDftToRef<FFT64>,
600 {
601 #[cfg(debug_assertions)]
602 {
603 assert_eq!(
604 self.rank(),
605 rhs.rank(),
606 "ggsw_out rank: {} != ggsw_apply: {}",
607 self.rank(),
608 rhs.rank()
609 );
610 }
611
612 let (tmp_data, scratch1) = scratch.tmp_vec_znx_dft(module, self.rank() + 1, self.size());
613
614 let mut tmp: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
615 data: tmp_data,
616 basek: self.basek(),
617 k: self.k(),
618 };
619
620 (0..self.rank() + 1).for_each(|col_i| {
621 (0..self.rows()).for_each(|row_j| {
622 self.get_row(module, row_j, col_i, &mut tmp);
623 tmp.external_product_inplace(module, rhs, scratch1);
624 self.set_row(module, row_j, col_i, &tmp);
625 });
626 });
627 }
628}
629
630impl<DataSelf> GGSWCiphertext<DataSelf, FFT64>
631where
632 MatZnxDft<DataSelf, FFT64>: MatZnxDftToRef<FFT64>,
633{
634 pub(crate) fn keyswitch_internal_col0<DataRes, DataKsk>(
635 &self,
636 module: &Module<FFT64>,
637 row_i: usize,
638 res: &mut GLWECiphertext<DataRes>,
639 ksk: &GLWESwitchingKey<DataKsk, FFT64>,
640 scratch: &mut Scratch,
641 ) where
642 VecZnx<DataRes>: VecZnxToMut,
643 MatZnxDft<DataKsk, FFT64>: MatZnxDftToRef<FFT64>,
644 {
645 #[cfg(debug_assertions)]
646 {
647 assert_eq!(self.rank(), ksk.rank());
648 assert_eq!(res.rank(), ksk.rank());
649 }
650
651 let (tmp_dft_in_data, scratch2) = scratch.tmp_vec_znx_dft(module, self.rank() + 1, self.size());
652 let mut tmp_dft_in: GLWECiphertextFourier<&mut [u8], FFT64> = GLWECiphertextFourier::<&mut [u8], FFT64> {
653 data: tmp_dft_in_data,
654 basek: self.basek(),
655 k: self.k(),
656 };
657 self.get_row(module, row_i, 0, &mut tmp_dft_in);
658 res.keyswitch_from_fourier(module, &tmp_dft_in, ksk, scratch2);
659 }
660}
661
662impl<DataSelf> GetRow<FFT64> for GGSWCiphertext<DataSelf, FFT64>
663where
664 MatZnxDft<DataSelf, FFT64>: MatZnxDftToRef<FFT64>,
665{
666 fn get_row<R>(&self, module: &Module<FFT64>, row_i: usize, col_j: usize, res: &mut R)
667 where
668 R: VecZnxDftToMut<FFT64>,
669 {
670 module.vmp_extract_row(res, self, row_i, col_j);
671 }
672}
673
674impl<DataSelf> SetRow<FFT64> for GGSWCiphertext<DataSelf, FFT64>
675where
676 MatZnxDft<DataSelf, FFT64>: MatZnxDftToMut<FFT64>,
677{
678 fn set_row<R>(&mut self, module: &Module<FFT64>, row_i: usize, col_j: usize, a: &R)
679 where
680 R: VecZnxDftToRef<FFT64>,
681 {
682 module.vmp_prepare_row(self, row_i, col_j, a);
683 }
684}