1use crate::decomposer::Decomposer;
  2
  3#[derive(Clone, PartialEq)]
  4pub(super) struct BoolParameters<El> {
  5    rlwe_q: Modulus<El>,
  6    lwe_q: Modulus<El>,
  7    br_q: Modulus<El>,
  8    rlwe_n: PolynomialSize,
  9    lwe_n: LweDimension,
 10    lwe_decomposer_base: DecompostionLogBase,
 11    lwe_decomposer_count: DecompositionCount,
 12    rlrg_decomposer_base: DecompostionLogBase,
 13    /// RLWE x RGSW decomposition count for (part A, part B)
 14    rlrg_decomposer_count: (DecompositionCount, DecompositionCount),
 15    rgrg_decomposer_base: DecompostionLogBase,
 16    /// RGSW x RGSW decomposition count for (part A, part B)
 17    rgrg_decomposer_count: (DecompositionCount, DecompositionCount),
 18    auto_decomposer_base: DecompostionLogBase,
 19    auto_decomposer_count: DecompositionCount,
 20    g: usize,
 21    w: usize,
 22}
 23
 24impl<El> BoolParameters<El> {
 25    pub(crate) fn rlwe_q(&self) -> &Modulus<El> {
 26        &self.rlwe_q
 27    }
 28
 29    pub(crate) fn lwe_q(&self) -> &Modulus<El> {
 30        &self.lwe_q
 31    }
 32
 33    pub(crate) fn br_q(&self) -> &Modulus<El> {
 34        &self.br_q
 35    }
 36
 37    pub(crate) fn rlwe_n(&self) -> &PolynomialSize {
 38        &self.rlwe_n
 39    }
 40
 41    pub(crate) fn lwe_n(&self) -> &LweDimension {
 42        &self.lwe_n
 43    }
 44
 45    pub(crate) fn g(&self) -> usize {
 46        self.g
 47    }
 48
 49    pub(crate) fn w(&self) -> usize {
 50        self.w
 51    }
 52
 53    pub(crate) fn rlwe_rgsw_decomposition_base(&self) -> DecompostionLogBase {
 54        self.rlrg_decomposer_base
 55    }
 56
 57    pub(crate) fn rlwe_rgsw_decomposition_count(&self) -> (DecompositionCount, DecompositionCount) {
 58        self.rlrg_decomposer_count
 59    }
 60
 61    pub(crate) fn rgsw_rgsw_decomposition_base(&self) -> DecompostionLogBase {
 62        self.rgrg_decomposer_base
 63    }
 64
 65    pub(crate) fn rgsw_rgsw_decomposition_count(&self) -> (DecompositionCount, DecompositionCount) {
 66        self.rgrg_decomposer_count
 67    }
 68
 69    pub(crate) fn auto_decomposition_base(&self) -> DecompostionLogBase {
 70        self.auto_decomposer_base
 71    }
 72
 73    pub(crate) fn auto_decomposition_count(&self) -> DecompositionCount {
 74        self.auto_decomposer_count
 75    }
 76
 77    pub(crate) fn lwe_decomposition_base(&self) -> DecompostionLogBase {
 78        self.lwe_decomposer_base
 79    }
 80
 81    pub(crate) fn lwe_decomposition_count(&self) -> DecompositionCount {
 82        self.lwe_decomposer_count
 83    }
 84
 85    pub(crate) fn rgsw_rgsw_decomposer<D: Decomposer<Element = El>>(&self) -> (D, D)
 86    where
 87        El: Copy,
 88    {
 89        (
 90            // A
 91            D::new(
 92                self.rlwe_q.0,
 93                self.rgrg_decomposer_base.0,
 94                self.rgrg_decomposer_count.0 .0,
 95            ),
 96            // B
 97            D::new(
 98                self.rlwe_q.0,
 99                self.rgrg_decomposer_base.0,
100                self.rgrg_decomposer_count.1 .0,
101            ),
102        )
103    }
104
105    pub(crate) fn auto_decomposer<D: Decomposer<Element = El>>(&self) -> D
106    where
107        El: Copy,
108    {
109        D::new(
110            self.rlwe_q.0,
111            self.auto_decomposer_base.0,
112            self.auto_decomposer_count.0,
113        )
114    }
115
116    pub(crate) fn lwe_decomposer<D: Decomposer<Element = El>>(&self) -> D
117    where
118        El: Copy,
119    {
120        D::new(
121            self.lwe_q.0,
122            self.lwe_decomposer_base.0,
123            self.lwe_decomposer_count.0,
124        )
125    }
126
127    pub(crate) fn rlwe_rgsw_decomposer<D: Decomposer<Element = El>>(&self) -> (D, D)
128    where
129        El: Copy,
130    {
131        (
132            // A
133            D::new(
134                self.rlwe_q.0,
135                self.rlrg_decomposer_base.0,
136                self.rlrg_decomposer_count.0 .0,
137            ),
138            // B
139            D::new(
140                self.rlwe_q.0,
141                self.rlrg_decomposer_base.0,
142                self.rlrg_decomposer_count.1 .0,
143            ),
144        )
145    }
146}
147
148#[derive(Clone, Copy, PartialEq)]
149struct DecompostionLogBase(pub(crate) usize);
150impl AsRef<usize> for DecompostionLogBase {
151    fn as_ref(&self) -> &usize {
152        &self.0
153    }
154}
155#[derive(Clone, Copy, PartialEq)]
156struct DecompositionCount(pub(crate) usize);
157impl AsRef<usize> for DecompositionCount {
158    fn as_ref(&self) -> &usize {
159        &self.0
160    }
161}
162
163#[derive(Clone, Copy, PartialEq)]
164struct LweDimension(pub(crate) usize);
165#[derive(Clone, Copy, PartialEq)]
166struct PolynomialSize(pub(crate) usize);
167#[derive(Clone, Copy, PartialEq)]
168struct Modulus<T>(pub(crate) T);
169
170pub(super) const SP_BOOL_PARAMS: BoolParameters<u64> = BoolParameters::<u64> {
171    rlwe_q: Modulus(268369921u64),
172    lwe_q: Modulus(1 << 16),
173    br_q: Modulus(1 << 10),
174    rlwe_n: PolynomialSize(1 << 10),
175    lwe_n: LweDimension(493),
176    lwe_decomposer_base: DecompostionLogBase(4),
177    lwe_decomposer_count: DecompositionCount(4),
178    rlrg_decomposer_base: DecompostionLogBase(7),
179    rlrg_decomposer_count: (DecompositionCount(4), DecompositionCount(4)),
180    rgrg_decomposer_base: DecompostionLogBase(7),
181    rgrg_decomposer_count: (DecompositionCount(4), DecompositionCount(4)),
182    auto_decomposer_base: DecompostionLogBase(7),
183    auto_decomposer_count: DecompositionCount(4),
184    g: 5,
185    w: 1,
186};
187
188pub(super) const MP_BOOL_PARAMS: BoolParameters<u64> = BoolParameters::<u64> {
189    rlwe_q: Modulus(1152921504606830593),
190    lwe_q: Modulus(1 << 20),
191    br_q: Modulus(1 << 11),
192    rlwe_n: PolynomialSize(1 << 11),
193    lwe_n: LweDimension(500),
194    lwe_decomposer_base: DecompostionLogBase(4),
195    lwe_decomposer_count: DecompositionCount(5),
196    rlrg_decomposer_base: DecompostionLogBase(12),
197    rlrg_decomposer_count: (DecompositionCount(5), DecompositionCount(5)),
198    rgrg_decomposer_base: DecompostionLogBase(12),
199    rgrg_decomposer_count: (DecompositionCount(5), DecompositionCount(5)),
200    auto_decomposer_base: DecompostionLogBase(12),
201    auto_decomposer_count: DecompositionCount(5),
202    g: 5,
203    w: 1,
204};
205
206#[cfg(test)]
207mod tests {
208    use crate::utils::generate_prime;
209
210    #[test]
211    fn find_prime() {
212        let bits = 61;
213        let ring_size = 1 << 11;
214        let prime = generate_prime(bits, ring_size * 2, 1 << bits).unwrap();
215        dbg!(prime);
216    }
217}