1use backend::hal::{
  2    api::{ScratchAvailable, TakeVecZnx, TakeVecZnxDft, VecZnxAddScalarInplace, VecZnxNormalizeInplace, ZnxZero},
  3    layouts::{Backend, DataMut, DataRef, Module, ScalarZnx, Scratch, VecZnx},
  4};
  5use sampling::source::Source;
  6
  7use crate::{
  8    GGLWEEncryptSkFamily, GGSWCiphertext, GGSWCiphertextCompressed, GLWECiphertext, GLWEEncryptSkFamily, GLWESecretExec, Infos,
  9    TakeGLWEPt, encrypt_sk_internal,
 10};
 11
 12pub trait GGSWEncryptSkFamily<B: Backend> = GLWEEncryptSkFamily<B>;
 13
 14impl GGSWCiphertext<Vec<u8>> {
 15    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
 16    where
 17        Module<B>: GGSWEncryptSkFamily<B>,
 18    {
 19        let size = k.div_ceil(basek);
 20        GLWECiphertext::encrypt_sk_scratch_space(module, n, basek, k)
 21            + VecZnx::alloc_bytes(n, rank + 1, size)
 22            + VecZnx::alloc_bytes(n, 1, size)
 23            + module.vec_znx_dft_alloc_bytes(n, rank + 1, size)
 24    }
 25}
 26
 27impl<DataSelf: DataMut> GGSWCiphertext<DataSelf> {
 28    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
 29        &mut self,
 30        module: &Module<B>,
 31        pt: &ScalarZnx<DataPt>,
 32        sk: &GLWESecretExec<DataSk, B>,
 33        source_xa: &mut Source,
 34        source_xe: &mut Source,
 35        sigma: f64,
 36        scratch: &mut Scratch<B>,
 37    ) where
 38        Module<B>: GGSWEncryptSkFamily<B> + VecZnxAddScalarInplace,
 39        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
 40    {
 41        #[cfg(debug_assertions)]
 42        {
 43            use backend::hal::api::ZnxInfos;
 44
 45            assert_eq!(self.rank(), sk.rank());
 46            assert_eq!(self.n(), sk.n());
 47            assert_eq!(pt.n(), sk.n());
 48        }
 49
 50        let basek: usize = self.basek();
 51        let k: usize = self.k();
 52        let rank: usize = self.rank();
 53        let digits: usize = self.digits();
 54
 55        let (mut tmp_pt, scratch1) = scratch.take_glwe_pt(self.n(), basek, k);
 56
 57        (0..self.rows()).for_each(|row_i| {
 58            tmp_pt.data.zero();
 59
 60            // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
 61            module.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (digits - 1) + row_i * digits, pt, 0);
 62            module.vec_znx_normalize_inplace(basek, &mut tmp_pt.data, 0, scratch1);
 63
 64            (0..rank + 1).for_each(|col_j| {
 65                // rlwe encrypt of vec_znx_pt into vec_znx_ct
 66
 67                self.at_mut(row_i, col_j).encrypt_sk_internal(
 68                    module,
 69                    Some((&tmp_pt, col_j)),
 70                    sk,
 71                    source_xa,
 72                    source_xe,
 73                    sigma,
 74                    scratch1,
 75                );
 76            });
 77        });
 78    }
 79}
 80
 81impl GGSWCiphertextCompressed<Vec<u8>> {
 82    pub fn encrypt_sk_scratch_space<B: Backend>(module: &Module<B>, n: usize, basek: usize, k: usize, rank: usize) -> usize
 83    where
 84        Module<B>: GGSWEncryptSkFamily<B>,
 85    {
 86        GGSWCiphertext::encrypt_sk_scratch_space(module, n, basek, k, rank)
 87    }
 88}
 89
 90impl<DataSelf: DataMut> GGSWCiphertextCompressed<DataSelf> {
 91    pub fn encrypt_sk<DataPt: DataRef, DataSk: DataRef, B: Backend>(
 92        &mut self,
 93        module: &Module<B>,
 94        pt: &ScalarZnx<DataPt>,
 95        sk: &GLWESecretExec<DataSk, B>,
 96        seed_xa: [u8; 32],
 97        source_xe: &mut Source,
 98        sigma: f64,
 99        scratch: &mut Scratch<B>,
100    ) where
101        Module<B>: GGSWEncryptSkFamily<B> + VecZnxAddScalarInplace,
102        Scratch<B>: TakeVecZnxDft<B> + ScratchAvailable + TakeVecZnx,
103    {
104        #[cfg(debug_assertions)]
105        {
106            use backend::hal::api::ZnxInfos;
107
108            assert_eq!(self.rank(), sk.rank());
109            assert_eq!(self.n(), sk.n());
110            assert_eq!(pt.n(), sk.n());
111        }
112
113        let basek: usize = self.basek();
114        let k: usize = self.k();
115        let rank: usize = self.rank();
116        let cols: usize = rank + 1;
117        let digits: usize = self.digits();
118
119        let (mut tmp_pt, scratch_1) = scratch.take_glwe_pt(self.n(), basek, k);
120
121        let mut source = Source::new(seed_xa);
122
123        self.seed = vec![[0u8; 32]; self.rows() * cols];
124
125        (0..self.rows()).for_each(|row_i| {
126            tmp_pt.data.zero();
127
128            // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt
129            module.vec_znx_add_scalar_inplace(&mut tmp_pt.data, 0, (digits - 1) + row_i * digits, pt, 0);
130            module.vec_znx_normalize_inplace(basek, &mut tmp_pt.data, 0, scratch_1);
131
132            (0..rank + 1).for_each(|col_j| {
133                // rlwe encrypt of vec_znx_pt into vec_znx_ct
134
135                let (seed, mut source_xa_tmp) = source.branch();
136
137                self.seed[row_i * cols + col_j] = seed;
138
139                encrypt_sk_internal(
140                    module,
141                    self.basek(),
142                    self.k(),
143                    &mut self.at_mut(row_i, col_j).data,
144                    cols,
145                    true,
146                    Some((&tmp_pt, col_j)),
147                    sk,
148                    &mut source_xa_tmp,
149                    source_xe,
150                    sigma,
151                    scratch_1,
152                );
153            });
154        });
155    }
156}