poulpy/core/src/lib.rs
core/src/lib.rsRaw
1pub mod automorphism;
2pub mod elem;
3pub mod gglwe_ciphertext;
4pub mod ggsw_ciphertext;
5pub mod glwe_ciphertext;
6pub mod glwe_ciphertext_fourier;
7pub mod glwe_keys;
8pub mod glwe_ops;
9pub mod glwe_packing;
10pub mod glwe_plaintext;
11pub mod keyswitch_key;
12pub mod tensor_key;
13#[cfg(test)]
14mod test_fft64;
15pub mod trace;
16mod utils;
17
18pub use automorphism::*;
19use backend::Backend;
20use backend::FFT64;
21use backend::Module;
22pub use elem::*;
23pub use gglwe_ciphertext::*;
24pub use ggsw_ciphertext::*;
25pub use glwe_ciphertext::*;
26pub use glwe_ciphertext_fourier::*;
27pub use glwe_keys::*;
28pub use glwe_ops::*;
29pub use glwe_packing::*;
30pub use glwe_plaintext::*;
31pub use keyswitch_key::*;
32pub use tensor_key::*;
33
34pub use backend::Scratch;
35pub use backend::ScratchOwned;
36use utils::div_ceil;
37
38pub(crate) const SIX_SIGMA: f64 = 6.0;
39
40pub trait ScratchCore<B: Backend> {
41 fn tmp_glwe_ct(&mut self, module: &Module<B>, basek: usize, k: usize, rank: usize) -> (GLWECiphertext<&mut [u8]>, &mut Self);
42 fn tmp_glwe_pt(&mut self, module: &Module<B>, basek: usize, k: usize) -> (GLWEPlaintext<&mut [u8]>, &mut Self);
43 fn tmp_gglwe(
44 &mut self,
45 module: &Module<B>,
46 basek: usize,
47 k: usize,
48 rows: usize,
49 digits: usize,
50 rank_in: usize,
51 rank_out: usize,
52 ) -> (GGLWECiphertext<&mut [u8], B>, &mut Self);
53 fn tmp_ggsw(
54 &mut self,
55 module: &Module<B>,
56 basek: usize,
57 k: usize,
58 rows: usize,
59 digits: usize,
60 rank: usize,
61 ) -> (GGSWCiphertext<&mut [u8], B>, &mut Self);
62 fn tmp_glwe_fourier(
63 &mut self,
64 module: &Module<B>,
65 basek: usize,
66 k: usize,
67 rank: usize,
68 ) -> (GLWECiphertextFourier<&mut [u8], B>, &mut Self);
69 fn tmp_sk(&mut self, module: &Module<B>, rank: usize) -> (GLWESecret<&mut [u8], B>, &mut Self);
70 fn tmp_glwe_pk(
71 &mut self,
72 module: &Module<B>,
73 basek: usize,
74 k: usize,
75 rank: usize,
76 ) -> (GLWEPublicKey<&mut [u8], B>, &mut Self);
77 fn tmp_glwe_ksk(
78 &mut self,
79 module: &Module<B>,
80 basek: usize,
81 k: usize,
82 rows: usize,
83 digits: usize,
84 rank_in: usize,
85 rank_out: usize,
86 ) -> (GLWESwitchingKey<&mut [u8], B>, &mut Self);
87 fn tmp_tsk(
88 &mut self,
89 module: &Module<B>,
90 basek: usize,
91 k: usize,
92 rows: usize,
93 digits: usize,
94 rank: usize,
95 ) -> (TensorKey<&mut [u8], B>, &mut Self);
96 fn tmp_autokey(
97 &mut self,
98 module: &Module<B>,
99 basek: usize,
100 k: usize,
101 rows: usize,
102 digits: usize,
103 rank: usize,
104 ) -> (AutomorphismKey<&mut [u8], B>, &mut Self);
105}
106
107impl ScratchCore<FFT64> for Scratch {
108 fn tmp_glwe_ct(
109 &mut self,
110 module: &Module<FFT64>,
111 basek: usize,
112 k: usize,
113 rank: usize,
114 ) -> (GLWECiphertext<&mut [u8]>, &mut Self) {
115 let (data, scratch) = self.tmp_vec_znx(module, rank + 1, div_ceil(k, basek));
116 (GLWECiphertext { data, basek, k }, scratch)
117 }
118
119 fn tmp_glwe_pt(&mut self, module: &Module<FFT64>, basek: usize, k: usize) -> (GLWEPlaintext<&mut [u8]>, &mut Self) {
120 let (data, scratch) = self.tmp_vec_znx(module, 1, div_ceil(k, basek));
121 (GLWEPlaintext { data, basek, k }, scratch)
122 }
123
124 fn tmp_gglwe(
125 &mut self,
126 module: &Module<FFT64>,
127 basek: usize,
128 k: usize,
129 rows: usize,
130 digits: usize,
131 rank_in: usize,
132 rank_out: usize,
133 ) -> (GGLWECiphertext<&mut [u8], FFT64>, &mut Self) {
134 let (data, scratch) = self.tmp_mat_znx_dft(
135 module,
136 div_ceil(rows, digits),
137 rank_in,
138 rank_out + 1,
139 div_ceil(k, basek),
140 );
141 (
142 GGLWECiphertext {
143 data: data,
144 basek: basek,
145 k,
146 digits,
147 },
148 scratch,
149 )
150 }
151
152 fn tmp_ggsw(
153 &mut self,
154 module: &Module<FFT64>,
155 basek: usize,
156 k: usize,
157 rows: usize,
158 digits: usize,
159 rank: usize,
160 ) -> (GGSWCiphertext<&mut [u8], FFT64>, &mut Self) {
161 let (data, scratch) = self.tmp_mat_znx_dft(
162 module,
163 div_ceil(rows, digits),
164 rank + 1,
165 rank + 1,
166 div_ceil(k, basek),
167 );
168 (
169 GGSWCiphertext {
170 data,
171 basek,
172 k,
173 digits,
174 },
175 scratch,
176 )
177 }
178
179 fn tmp_glwe_fourier(
180 &mut self,
181 module: &Module<FFT64>,
182 basek: usize,
183 k: usize,
184 rank: usize,
185 ) -> (GLWECiphertextFourier<&mut [u8], FFT64>, &mut Self) {
186 let (data, scratch) = self.tmp_vec_znx_dft(module, rank + 1, div_ceil(k, basek));
187 (GLWECiphertextFourier { data, basek, k }, scratch)
188 }
189
190 fn tmp_glwe_pk(
191 &mut self,
192 module: &Module<FFT64>,
193 basek: usize,
194 k: usize,
195 rank: usize,
196 ) -> (GLWEPublicKey<&mut [u8], FFT64>, &mut Self) {
197 let (data, scratch) = self.tmp_glwe_fourier(module, basek, k, rank);
198 (
199 GLWEPublicKey {
200 data,
201 dist: SecretDistribution::NONE,
202 },
203 scratch,
204 )
205 }
206
207 fn tmp_sk(&mut self, module: &Module<FFT64>, rank: usize) -> (GLWESecret<&mut [u8], FFT64>, &mut Self) {
208 let (data, scratch) = self.tmp_scalar_znx(module, rank);
209 let (data_fourier, scratch1) = scratch.tmp_scalar_znx_dft(module, rank);
210 (
211 GLWESecret {
212 data,
213 data_fourier,
214 dist: SecretDistribution::NONE,
215 },
216 scratch1,
217 )
218 }
219
220 fn tmp_glwe_ksk(
221 &mut self,
222 module: &Module<FFT64>,
223 basek: usize,
224 k: usize,
225 rows: usize,
226 digits: usize,
227 rank_in: usize,
228 rank_out: usize,
229 ) -> (GLWESwitchingKey<&mut [u8], FFT64>, &mut Self) {
230 let (data, scratch) = self.tmp_gglwe(module, basek, k, rows, digits, rank_in, rank_out);
231 (GLWESwitchingKey(data), scratch)
232 }
233
234 fn tmp_autokey(
235 &mut self,
236 module: &Module<FFT64>,
237 basek: usize,
238 k: usize,
239 rows: usize,
240 digits: usize,
241 rank: usize,
242 ) -> (AutomorphismKey<&mut [u8], FFT64>, &mut Self) {
243 let (data, scratch) = self.tmp_glwe_ksk(module, basek, k, rows, digits, rank, rank);
244 (AutomorphismKey { key: data, p: 0 }, scratch)
245 }
246
247 fn tmp_tsk(
248 &mut self,
249 module: &Module<FFT64>,
250 basek: usize,
251 k: usize,
252 rows: usize,
253 digits: usize,
254 rank: usize,
255 ) -> (TensorKey<&mut [u8], FFT64>, &mut Self) {
256 let mut keys: Vec<GLWESwitchingKey<&mut [u8], FFT64>> = Vec::new();
257 let pairs: usize = (((rank + 1) * rank) >> 1).max(1);
258
259 let mut scratch: &mut Scratch = self;
260
261 if pairs != 0 {
262 let (gglwe, s) = scratch.tmp_glwe_ksk(module, basek, k, rows, digits, 1, rank);
263 scratch = s;
264 keys.push(gglwe);
265 }
266 for _ in 1..pairs {
267 let (gglwe, s) = scratch.tmp_glwe_ksk(module, basek, k, rows, digits, 1, rank);
268 scratch = s;
269 keys.push(gglwe);
270 }
271 (TensorKey { keys }, scratch)
272 }
273}