1use num_traits::{ConstZero, PrimInt, Zero};
  2
  3use crate::{backend::Modulus, decomposer::Decomposer};
  4
  5#[derive(Clone, PartialEq)]
  6pub(super) struct BoolParameters<El> {
  7    rlwe_q: CiphertextModulus<El>,
  8    lwe_q: CiphertextModulus<El>,
  9    br_q: usize,
 10    rlwe_n: PolynomialSize,
 11    lwe_n: LweDimension,
 12    lwe_decomposer_base: DecompostionLogBase,
 13    lwe_decomposer_count: DecompositionCount,
 14    rlrg_decomposer_base: DecompostionLogBase,
 15    /// RLWE x RGSW decomposition count for (part A, part B)
 16    rlrg_decomposer_count: (DecompositionCount, DecompositionCount),
 17    rgrg_decomposer_base: DecompostionLogBase,
 18    /// RGSW x RGSW decomposition count for (part A, part B)
 19    rgrg_decomposer_count: (DecompositionCount, DecompositionCount),
 20    auto_decomposer_base: DecompostionLogBase,
 21    auto_decomposer_count: DecompositionCount,
 22    g: usize,
 23    w: usize,
 24}
 25
 26impl<El> BoolParameters<El> {
 27    pub(crate) fn rlwe_q(&self) -> &CiphertextModulus<El> {
 28        &self.rlwe_q
 29    }
 30
 31    pub(crate) fn lwe_q(&self) -> &CiphertextModulus<El> {
 32        &self.lwe_q
 33    }
 34
 35    pub(crate) fn br_q(&self) -> &usize {
 36        &self.br_q
 37    }
 38
 39    pub(crate) fn rlwe_n(&self) -> &PolynomialSize {
 40        &self.rlwe_n
 41    }
 42
 43    pub(crate) fn lwe_n(&self) -> &LweDimension {
 44        &self.lwe_n
 45    }
 46
 47    pub(crate) fn g(&self) -> usize {
 48        self.g
 49    }
 50
 51    pub(crate) fn w(&self) -> usize {
 52        self.w
 53    }
 54
 55    pub(crate) fn rlwe_rgsw_decomposition_base(&self) -> DecompostionLogBase {
 56        self.rlrg_decomposer_base
 57    }
 58
 59    pub(crate) fn rlwe_rgsw_decomposition_count(&self) -> (DecompositionCount, DecompositionCount) {
 60        self.rlrg_decomposer_count
 61    }
 62
 63    pub(crate) fn rgsw_rgsw_decomposition_base(&self) -> DecompostionLogBase {
 64        self.rgrg_decomposer_base
 65    }
 66
 67    pub(crate) fn rgsw_rgsw_decomposition_count(&self) -> (DecompositionCount, DecompositionCount) {
 68        self.rgrg_decomposer_count
 69    }
 70
 71    pub(crate) fn auto_decomposition_base(&self) -> DecompostionLogBase {
 72        self.auto_decomposer_base
 73    }
 74
 75    pub(crate) fn auto_decomposition_count(&self) -> DecompositionCount {
 76        self.auto_decomposer_count
 77    }
 78
 79    pub(crate) fn lwe_decomposition_base(&self) -> DecompostionLogBase {
 80        self.lwe_decomposer_base
 81    }
 82
 83    pub(crate) fn lwe_decomposition_count(&self) -> DecompositionCount {
 84        self.lwe_decomposer_count
 85    }
 86
 87    pub(crate) fn rgsw_rgsw_decomposer<D: Decomposer<Element = El>>(&self) -> (D, D)
 88    where
 89        El: Copy,
 90    {
 91        (
 92            // A
 93            D::new(
 94                self.rlwe_q.0,
 95                self.rgrg_decomposer_base.0,
 96                self.rgrg_decomposer_count.0 .0,
 97            ),
 98            // B
 99            D::new(
100                self.rlwe_q.0,
101                self.rgrg_decomposer_base.0,
102                self.rgrg_decomposer_count.1 .0,
103            ),
104        )
105    }
106
107    pub(crate) fn auto_decomposer<D: Decomposer<Element = El>>(&self) -> D
108    where
109        El: Copy,
110    {
111        D::new(
112            self.rlwe_q.0,
113            self.auto_decomposer_base.0,
114            self.auto_decomposer_count.0,
115        )
116    }
117
118    pub(crate) fn lwe_decomposer<D: Decomposer<Element = El>>(&self) -> D
119    where
120        El: Copy,
121    {
122        D::new(
123            self.lwe_q.0,
124            self.lwe_decomposer_base.0,
125            self.lwe_decomposer_count.0,
126        )
127    }
128
129    pub(crate) fn rlwe_rgsw_decomposer<D: Decomposer<Element = El>>(&self) -> (D, D)
130    where
131        El: Copy,
132    {
133        (
134            // A
135            D::new(
136                self.rlwe_q.0,
137                self.rlrg_decomposer_base.0,
138                self.rlrg_decomposer_count.0 .0,
139            ),
140            // B
141            D::new(
142                self.rlwe_q.0,
143                self.rlrg_decomposer_base.0,
144                self.rlrg_decomposer_count.1 .0,
145            ),
146        )
147    }
148}
149
150#[derive(Clone, Copy, PartialEq)]
151pub(crate) struct DecompostionLogBase(pub(crate) usize);
152impl AsRef<usize> for DecompostionLogBase {
153    fn as_ref(&self) -> &usize {
154        &self.0
155    }
156}
157#[derive(Clone, Copy, PartialEq)]
158pub(crate) struct DecompositionCount(pub(crate) usize);
159impl AsRef<usize> for DecompositionCount {
160    fn as_ref(&self) -> &usize {
161        &self.0
162    }
163}
164#[derive(Clone, Copy, PartialEq)]
165pub(crate) struct LweDimension(pub(crate) usize);
166#[derive(Clone, Copy, PartialEq)]
167pub(crate) struct PolynomialSize(pub(crate) usize);
168#[derive(Clone, Copy, PartialEq)]
169
170/// T eqauls modulus when modulus is non-native. Otherwise T equals 0. bool is
171/// true when modulus is native, false otherwise.
172pub(crate) struct CiphertextModulus<T>(T, bool);
173
174impl<T: ConstZero> CiphertextModulus<T> {
175    const fn new_native() -> Self {
176        // T::zero is stored only for convenience. It has no use when modulus
177        // is native. That is, either u128,u64,u32,u16
178        Self(T::ZERO, true)
179    }
180
181    const fn new_non_native(q: T) -> Self {
182        Self(q, false)
183    }
184}
185
186impl<T> Modulus for CiphertextModulus<T>
187where
188    T: PrimInt,
189{
190    type Element = T;
191    fn is_native(&self) -> bool {
192        false
193    }
194    fn largest_unsigned_value(&self) -> Self::Element {
195        if self.1 {
196            T::max_value()
197        } else {
198            self.0 - T::one()
199        }
200    }
201    fn neg_one(&self) -> Self::Element {
202        if self.1 {
203            T::max_value()
204        } else {
205            self.0 - T::one()
206        }
207    }
208    // fn signed_max(&self) -> Self::Element {}
209    // fn signed_min(&self) -> Self::Element {}
210    fn smallest_unsigned_value(&self) -> Self::Element {
211        T::zero()
212    }
213
214    fn to_i64(&self, v: &Self::Element) -> i64 {
215        todo!()
216    }
217
218    fn from_f64(&self, v: f64) -> Self::Element {
219        todo!()
220    }
221
222    fn from_i64(&self, v: i64) -> Self::Element {
223        todo!()
224    }
225
226    fn q(&self) -> Option<Self::Element> {
227        todo!()
228    }
229}
230
231pub(super) const SP_BOOL_PARAMS: BoolParameters<u64> = BoolParameters::<u64> {
232    rlwe_q: CiphertextModulus::new_non_native(268369921u64),
233    lwe_q: CiphertextModulus::new_non_native(1 << 16),
234    br_q: 1 << 10,
235    rlwe_n: PolynomialSize(1 << 10),
236    lwe_n: LweDimension(493),
237    lwe_decomposer_base: DecompostionLogBase(4),
238    lwe_decomposer_count: DecompositionCount(4),
239    rlrg_decomposer_base: DecompostionLogBase(7),
240    rlrg_decomposer_count: (DecompositionCount(4), DecompositionCount(4)),
241    rgrg_decomposer_base: DecompostionLogBase(7),
242    rgrg_decomposer_count: (DecompositionCount(4), DecompositionCount(4)),
243    auto_decomposer_base: DecompostionLogBase(7),
244    auto_decomposer_count: DecompositionCount(4),
245    g: 5,
246    w: 1,
247};
248
249pub(super) const MP_BOOL_PARAMS: BoolParameters<u64> = BoolParameters::<u64> {
250    rlwe_q: CiphertextModulus::new_non_native(1152921504606830593),
251    lwe_q: CiphertextModulus::new_non_native(1 << 20),
252    br_q: 1 << 10,
253    rlwe_n: PolynomialSize(1 << 11),
254    lwe_n: LweDimension(500),
255    lwe_decomposer_base: DecompostionLogBase(4),
256    lwe_decomposer_count: DecompositionCount(5),
257    rlrg_decomposer_base: DecompostionLogBase(12),
258    rlrg_decomposer_count: (DecompositionCount(5), DecompositionCount(5)),
259    rgrg_decomposer_base: DecompostionLogBase(12),
260    rgrg_decomposer_count: (DecompositionCount(5), DecompositionCount(5)),
261    auto_decomposer_base: DecompostionLogBase(12),
262    auto_decomposer_count: DecompositionCount(5),
263    g: 5,
264    w: 1,
265};
266
267#[cfg(test)]
268mod tests {
269    use crate::utils::generate_prime;
270
271    #[test]
272    fn find_prime() {
273        let bits = 61;
274        let ring_size = 1 << 11;
275        let prime = generate_prime(bits, ring_size * 2, 1 << bits).unwrap();
276        dbg!(prime);
277    }
278}