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