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