1use backend::hal::{
  2    api::{FillUniform, Reset},
  3    layouts::{Backend, Data, DataMut, DataRef, MatZnx, Module, ReaderFrom, WriterTo},
  4};
  5
  6use crate::{GGLWEEncryptSkFamily, GLWESecret, GLWESecretExec, GLWESwitchingKey, Infos};
  7
  8use std::fmt;
  9
 10/// A special [GLWESwitchingKey] required to for the conversion from [GLWECiphertext] to [LWECiphertext].
 11#[derive(PartialEq, Eq, Clone)]
 12pub struct GLWEToLWESwitchingKey<D: Data>(pub(crate) GLWESwitchingKey<D>);
 13
 14impl<D: DataRef> fmt::Debug for GLWEToLWESwitchingKey<D> {
 15    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 16        write!(f, "{}", self)
 17    }
 18}
 19
 20impl<D: DataMut> FillUniform for GLWEToLWESwitchingKey<D> {
 21    fn fill_uniform(&mut self, source: &mut sampling::source::Source) {
 22        self.0.fill_uniform(source);
 23    }
 24}
 25
 26impl<D: DataMut> Reset for GLWEToLWESwitchingKey<D> {
 27    fn reset(&mut self) {
 28        self.0.reset();
 29    }
 30}
 31
 32impl<D: DataRef> fmt::Display for GLWEToLWESwitchingKey<D> {
 33    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 34        write!(f, "(GLWEToLWESwitchingKey) {}", self.0)
 35    }
 36}
 37
 38impl<D: Data> Infos for GLWEToLWESwitchingKey<D> {
 39    type Inner = MatZnx<D>;
 40
 41    fn inner(&self) -> &Self::Inner {
 42        &self.0.inner()
 43    }
 44
 45    fn basek(&self) -> usize {
 46        self.0.basek()
 47    }
 48
 49    fn k(&self) -> usize {
 50        self.0.k()
 51    }
 52}
 53
 54impl<D: Data> GLWEToLWESwitchingKey<D> {
 55    pub fn digits(&self) -> usize {
 56        self.0.digits()
 57    }
 58
 59    pub fn rank(&self) -> usize {
 60        self.0.rank()
 61    }
 62
 63    pub fn rank_in(&self) -> usize {
 64        self.0.rank_in()
 65    }
 66
 67    pub fn rank_out(&self) -> usize {
 68        self.0.rank_out()
 69    }
 70}
 71
 72impl<D: DataMut> ReaderFrom for GLWEToLWESwitchingKey<D> {
 73    fn read_from<R: std::io::Read>(&mut self, reader: &mut R) -> std::io::Result<()> {
 74        self.0.read_from(reader)
 75    }
 76}
 77
 78impl<D: DataRef> WriterTo for GLWEToLWESwitchingKey<D> {
 79    fn write_to<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
 80        self.0.write_to(writer)
 81    }
 82}
 83
 84impl GLWEToLWESwitchingKey<Vec<u8>> {
 85    pub fn alloc(n: usize, basek: usize, k: usize, rows: usize, rank_in: usize) -> Self {
 86        Self(GLWESwitchingKey::alloc(n, basek, k, rows, 1, rank_in, 1))
 87    }
 88
 89    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank_in: usize) -> usize
 90    where
 91        Module<B>: GGLWEEncryptSkFamily<B>,
 92    {
 93        GLWESecretExec::bytes_of(module, n, rank_in)
 94            + (GLWESwitchingKey::encrypt_sk_scratch_space(module, n, basek, k, rank_in, 1) | GLWESecret::bytes_of(n, rank_in))
 95    }
 96}
 97
 98#[derive(PartialEq, Eq, Clone)]
 99pub struct LWEToGLWESwitchingKey<D: Data>(pub(crate) GLWESwitchingKey<D>);
100
101impl<D: DataRef> fmt::Debug for LWEToGLWESwitchingKey<D> {
102    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
103        write!(f, "{}", self)
104    }
105}
106
107impl<D: DataMut> FillUniform for LWEToGLWESwitchingKey<D> {
108    fn fill_uniform(&mut self, source: &mut sampling::source::Source) {
109        self.0.fill_uniform(source);
110    }
111}
112
113impl<D: DataMut> Reset for LWEToGLWESwitchingKey<D> {
114    fn reset(&mut self) {
115        self.0.reset();
116    }
117}
118
119impl<D: DataRef> fmt::Display for LWEToGLWESwitchingKey<D> {
120    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
121        write!(f, "(LWEToGLWESwitchingKey) {}", self.0)
122    }
123}
124
125impl<D: Data> Infos for LWEToGLWESwitchingKey<D> {
126    type Inner = MatZnx<D>;
127
128    fn inner(&self) -> &Self::Inner {
129        &self.0.inner()
130    }
131
132    fn basek(&self) -> usize {
133        self.0.basek()
134    }
135
136    fn k(&self) -> usize {
137        self.0.k()
138    }
139}
140
141impl<D: Data> LWEToGLWESwitchingKey<D> {
142    pub fn digits(&self) -> usize {
143        self.0.digits()
144    }
145
146    pub fn rank(&self) -> usize {
147        self.0.rank()
148    }
149
150    pub fn rank_in(&self) -> usize {
151        self.0.rank_in()
152    }
153
154    pub fn rank_out(&self) -> usize {
155        self.0.rank_out()
156    }
157}
158
159impl<D: DataMut> ReaderFrom for LWEToGLWESwitchingKey<D> {
160    fn read_from<R: std::io::Read>(&mut self, reader: &mut R) -> std::io::Result<()> {
161        self.0.read_from(reader)
162    }
163}
164
165impl<D: DataRef> WriterTo for LWEToGLWESwitchingKey<D> {
166    fn write_to<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
167        self.0.write_to(writer)
168    }
169}
170
171impl LWEToGLWESwitchingKey<Vec<u8>> {
172    pub fn alloc(n: usize, basek: usize, k: usize, rows: usize, rank_out: usize) -> Self {
173        Self(GLWESwitchingKey::alloc(n, basek, k, rows, 1, 1, rank_out))
174    }
175
176    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank_out: usize) -> usize
177    where
178        Module<B>: GGLWEEncryptSkFamily<B>,
179    {
180        GLWESwitchingKey::encrypt_sk_scratch_space(module, n, basek, k, 1, rank_out) + GLWESecret::bytes_of(n, 1)
181    }
182}
183
184#[derive(PartialEq, Eq, Clone)]
185pub struct LWESwitchingKey<D: Data>(pub(crate) GLWESwitchingKey<D>);
186
187impl<D: DataRef> fmt::Debug for LWESwitchingKey<D> {
188    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
189        write!(f, "{}", self)
190    }
191}
192
193impl<D: DataMut> FillUniform for LWESwitchingKey<D> {
194    fn fill_uniform(&mut self, source: &mut sampling::source::Source) {
195        self.0.fill_uniform(source);
196    }
197}
198
199impl<D: DataMut> Reset for LWESwitchingKey<D> {
200    fn reset(&mut self) {
201        self.0.reset();
202    }
203}
204
205impl<D: DataRef> fmt::Display for LWESwitchingKey<D> {
206    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
207        write!(f, "(LWESwitchingKey) {}", self.0)
208    }
209}
210
211impl<D: Data> Infos for LWESwitchingKey<D> {
212    type Inner = MatZnx<D>;
213
214    fn inner(&self) -> &Self::Inner {
215        &self.0.inner()
216    }
217
218    fn basek(&self) -> usize {
219        self.0.basek()
220    }
221
222    fn k(&self) -> usize {
223        self.0.k()
224    }
225}
226
227impl<D: Data> LWESwitchingKey<D> {
228    pub fn digits(&self) -> usize {
229        self.0.digits()
230    }
231
232    pub fn rank(&self) -> usize {
233        self.0.rank()
234    }
235
236    pub fn rank_in(&self) -> usize {
237        self.0.rank_in()
238    }
239
240    pub fn rank_out(&self) -> usize {
241        self.0.rank_out()
242    }
243}
244
245impl<D: DataMut> ReaderFrom for LWESwitchingKey<D> {
246    fn read_from<R: std::io::Read>(&mut self, reader: &mut R) -> std::io::Result<()> {
247        self.0.read_from(reader)
248    }
249}
250
251impl<D: DataRef> WriterTo for LWESwitchingKey<D> {
252    fn write_to<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
253        self.0.write_to(writer)
254    }
255}
256
257impl LWESwitchingKey<Vec<u8>> {
258    pub fn alloc(n: usize, basek: usize, k: usize, rows: usize) -> Self {
259        Self(GLWESwitchingKey::alloc(n, basek, k, rows, 1, 1, 1))
260    }
261
262    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize) -> usize
263    where
264        Module<B>: GGLWEEncryptSkFamily<B>,
265    {
266        GLWESecret::bytes_of(n, 1)
267            + GLWESecretExec::bytes_of(module, n, 1)
268            + GLWESwitchingKey::encrypt_sk_scratch_space(module, n, basek, k, 1, 1)
269    }
270}