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