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_ops;
8pub mod glwe_packing;
9pub mod glwe_plaintext;
10pub mod keys;
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_ops::*;
28pub use glwe_packing::*;
29pub use glwe_plaintext::*;
30pub use keys::*;
31pub use keyswitch_key::*;
32pub use tensor_key::*;
33
34pub use backend::Scratch;
35pub use backend::ScratchOwned;
36use utils::derive_size;
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 rank_in: usize,
50 rank_out: usize,
51 ) -> (GGLWECiphertext<&mut [u8], B>, &mut Self);
52 fn tmp_ggsw(
53 &mut self,
54 module: &Module<B>,
55 basek: usize,
56 k: usize,
57 rows: usize,
58 rank: usize,
59 ) -> (GGSWCiphertext<&mut [u8], B>, &mut Self);
60 fn tmp_glwe_fourier(
61 &mut self,
62 module: &Module<B>,
63 basek: usize,
64 k: usize,
65 rank: usize,
66 ) -> (GLWECiphertextFourier<&mut [u8], B>, &mut Self);
67 fn tmp_sk(&mut self, module: &Module<B>, rank: usize) -> (SecretKey<&mut [u8]>, &mut Self);
68 fn tmp_sk_fourier(&mut self, module: &Module<B>, rank: usize) -> (SecretKeyFourier<&mut [u8], B>, &mut Self);
69 fn tmp_glwe_pk(
70 &mut self,
71 module: &Module<B>,
72 basek: usize,
73 k: usize,
74 rank: usize,
75 ) -> (GLWEPublicKey<&mut [u8], B>, &mut Self);
76 fn tmp_glwe_ksk(
77 &mut self,
78 module: &Module<B>,
79 basek: usize,
80 k: usize,
81 rows: usize,
82 rank_in: usize,
83 rank_out: usize,
84 ) -> (GLWESwitchingKey<&mut [u8], B>, &mut Self);
85 fn tmp_tsk(
86 &mut self,
87 module: &Module<B>,
88 basek: usize,
89 k: usize,
90 rows: usize,
91 rank: usize,
92 ) -> (TensorKey<&mut [u8], B>, &mut Self);
93 fn tmp_autokey(
94 &mut self,
95 module: &Module<B>,
96 basek: usize,
97 k: usize,
98 rows: usize,
99 rank: usize,
100 ) -> (AutomorphismKey<&mut [u8], B>, &mut Self);
101}
102
103impl ScratchCore<FFT64> for Scratch {
104 fn tmp_glwe_ct(
105 &mut self,
106 module: &Module<FFT64>,
107 basek: usize,
108 k: usize,
109 rank: usize,
110 ) -> (GLWECiphertext<&mut [u8]>, &mut Self) {
111 let (data, scratch) = self.tmp_vec_znx(module, rank + 1, derive_size(basek, k));
112 (GLWECiphertext { data, basek, k }, scratch)
113 }
114
115 fn tmp_glwe_pt(&mut self, module: &Module<FFT64>, basek: usize, k: usize) -> (GLWEPlaintext<&mut [u8]>, &mut Self) {
116 let (data, scratch) = self.tmp_vec_znx(module, 1, derive_size(basek, k));
117 (GLWEPlaintext { data, basek, k }, scratch)
118 }
119
120 fn tmp_gglwe(
121 &mut self,
122 module: &Module<FFT64>,
123 basek: usize,
124 k: usize,
125 rows: usize,
126 rank_in: usize,
127 rank_out: usize,
128 ) -> (GGLWECiphertext<&mut [u8], FFT64>, &mut Self) {
129 let (data, scratch) = self.tmp_mat_znx_dft(module, rows, rank_in, rank_out + 1, derive_size(basek, k));
130 (
131 GGLWECiphertext {
132 data: data,
133 basek: basek,
134 k,
135 },
136 scratch,
137 )
138 }
139
140 fn tmp_ggsw(
141 &mut self,
142 module: &Module<FFT64>,
143 basek: usize,
144 k: usize,
145 rows: usize,
146 rank: usize,
147 ) -> (GGSWCiphertext<&mut [u8], FFT64>, &mut Self) {
148 let (data, scratch) = self.tmp_mat_znx_dft(module, rows, rank + 1, rank + 1, derive_size(basek, k));
149 (
150 GGSWCiphertext {
151 data: data,
152 basek: basek,
153 k,
154 },
155 scratch,
156 )
157 }
158
159 fn tmp_glwe_fourier(
160 &mut self,
161 module: &Module<FFT64>,
162 basek: usize,
163 k: usize,
164 rank: usize,
165 ) -> (GLWECiphertextFourier<&mut [u8], FFT64>, &mut Self) {
166 let (data, scratch) = self.tmp_vec_znx_dft(module, rank + 1, derive_size(basek, k));
167 (GLWECiphertextFourier { data, basek, k }, scratch)
168 }
169
170 fn tmp_glwe_pk(
171 &mut self,
172 module: &Module<FFT64>,
173 basek: usize,
174 k: usize,
175 rank: usize,
176 ) -> (GLWEPublicKey<&mut [u8], FFT64>, &mut Self) {
177 let (data, scratch) = self.tmp_glwe_fourier(module, basek, k, rank);
178 (
179 GLWEPublicKey {
180 data,
181 dist: SecretDistribution::NONE,
182 },
183 scratch,
184 )
185 }
186
187 fn tmp_sk(&mut self, module: &Module<FFT64>, rank: usize) -> (SecretKey<&mut [u8]>, &mut Self) {
188 let (data, scratch) = self.tmp_scalar_znx(module, rank + 1);
189 (
190 SecretKey {
191 data,
192 dist: SecretDistribution::NONE,
193 },
194 scratch,
195 )
196 }
197
198 fn tmp_sk_fourier(&mut self, module: &Module<FFT64>, rank: usize) -> (SecretKeyFourier<&mut [u8], FFT64>, &mut Self) {
199 let (data, scratch) = self.tmp_scalar_znx_dft(module, rank);
200 (
201 SecretKeyFourier {
202 data,
203 dist: SecretDistribution::NONE,
204 },
205 scratch,
206 )
207 }
208
209 fn tmp_glwe_ksk(
210 &mut self,
211 module: &Module<FFT64>,
212 basek: usize,
213 k: usize,
214 rows: usize,
215 rank_in: usize,
216 rank_out: usize,
217 ) -> (GLWESwitchingKey<&mut [u8], FFT64>, &mut Self) {
218 let (data, scratch) = self.tmp_gglwe(module, basek, k, rows, rank_in, rank_out);
219 (GLWESwitchingKey(data), scratch)
220 }
221
222 fn tmp_autokey(
223 &mut self,
224 module: &Module<FFT64>,
225 basek: usize,
226 k: usize,
227 rows: usize,
228 rank: usize,
229 ) -> (AutomorphismKey<&mut [u8], FFT64>, &mut Self) {
230 let (data, scratch) = self.tmp_glwe_ksk(module, basek, k, rows, rank, rank);
231 (AutomorphismKey { key: data, p: 0 }, scratch)
232 }
233
234 fn tmp_tsk(
235 &mut self,
236 module: &Module<FFT64>,
237 basek: usize,
238 k: usize,
239 rows: usize,
240 rank: usize,
241 ) -> (TensorKey<&mut [u8], FFT64>, &mut Self) {
242 let mut keys: Vec<GLWESwitchingKey<&mut [u8], FFT64>> = Vec::new();
243 let pairs: usize = (((rank + 1) * rank) >> 1).max(1);
244
245 let mut scratch: &mut Scratch = self;
246
247 if pairs != 0 {
248 let (gglwe, s) = scratch.tmp_glwe_ksk(module, basek, k, rows, 1, rank);
249 scratch = s;
250 keys.push(gglwe);
251 }
252 for _ in 1..pairs {
253 let (gglwe, s) = scratch.tmp_glwe_ksk(module, basek, k, rows, 1, rank);
254 scratch = s;
255 keys.push(gglwe);
256 }
257 (TensorKey { keys }, scratch)
258 }
259}