GLWESub

poulpy_core

Trait GLWESub 

Source 
pub trait GLWESub
where
    Self: ModuleN + VecZnxSub + VecZnxCopy + VecZnxNegateInplace + VecZnxSubInplace + VecZnxSubNegateInplace,
{
    // Provided methods
    fn glwe_sub<R, A, B>(&self, res: &mut R, a: &A, b: &B)
       where R: GLWEToMut,
             A: GLWEToRef,
             B: GLWEToRef { ... }
    fn glwe_sub_inplace<R, A>(&self, res: &mut R, a: &A)
       where R: GLWEToMut,
             A: GLWEToRef { ... }
    fn glwe_sub_negate_inplace<R, A>(&self, res: &mut R, a: &A)
       where R: GLWEToMut,
             A: GLWEToRef { ... }
}

Provided Methods§

Source

fn glwe_sub<R, A, B>(&self, res: &mut R, a: &A, b: &B)
where R: GLWEToMut, A: GLWEToRef, B: GLWEToRef,

Source

fn glwe_sub_inplace<R, A>(&self, res: &mut R, a: &A)
where R: GLWEToMut, A: GLWEToRef,

Examples found in repository?
examples/encryption.rs (line 85)
15fn main() {
16    // Ring degree
17    let log_n: usize = 10;
18
19    let n: Degree = Degree(1 << log_n);
20
21    // Base-2-k (implicit digit decomposition)
22    let base2k: Base2K = Base2K(14);
23
24    // Ciphertext Torus precision (equivalent to ciphertext modulus)
25    let k_ct: TorusPrecision = TorusPrecision(27);
26
27    // Plaintext Torus precision (equivament to plaintext modulus)
28    let k_pt: TorusPrecision = TorusPrecision(base2k.into());
29
30    // GLWE rank
31    let rank: Rank = Rank(1);
32
33    // Instantiate Module (DFT Tables)
34    let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(n.0 as u64);
35
36    let glwe_ct_infos: GLWELayout = GLWELayout {
37        n,
38        base2k,
39        k: k_ct,
40        rank,
41    };
42
43    let glwe_pt_infos: GLWEPlaintextLayout = GLWEPlaintextLayout { n, base2k, k: k_pt };
44
45    // Allocates ciphertext & plaintexts
46    let mut ct: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_ct_infos);
47    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
48    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
49
50    // CPRNG
51    let mut source_xs: Source = Source::new([0u8; 32]);
52    let mut source_xe: Source = Source::new([1u8; 32]);
53    let mut source_xa: Source = Source::new([2u8; 32]);
54
55    // Scratch space
56    let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
57        GLWE::encrypt_sk_tmp_bytes(&module, &glwe_ct_infos) | GLWE::decrypt_tmp_bytes(&module, &glwe_ct_infos),
58    );
59
60    // Generate secret-key
61    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_ct_infos);
62    sk.fill_ternary_prob(0.5, &mut source_xs);
63
64    // Backend-prepared secret
65    let mut sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
66    sk_prepared.prepare(&module, &sk);
67
68    // Uniform plaintext
69    module.vec_znx_fill_uniform(base2k.into(), &mut pt_want.data, 0, &mut source_xa);
70
71    // Encryption
72    ct.encrypt_sk(
73        &module,
74        &pt_want,
75        &sk_prepared,
76        &mut source_xa,
77        &mut source_xe,
78        scratch.borrow(),
79    );
80
81    // Decryption
82    ct.decrypt(&module, &mut pt_have, &sk_prepared, scratch.borrow());
83
84    // Diff between pt - Dec(Enc(pt))
85    module.glwe_sub_inplace(&mut pt_want, &pt_have);
86
87    // Ideal vs. actual noise
88    let noise_have: f64 = pt_want.data.std(base2k.into(), 0) * (ct.k().as_u32() as f64).exp2();
89    let noise_want: f64 = SIGMA;
90
91    // Check
92    assert!(noise_have <= noise_want + 0.2);
93}
Source

fn glwe_sub_negate_inplace<R, A>(&self, res: &mut R, a: &A)
where R: GLWEToMut, A: GLWEToRef,

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

impl<BE: Backend> GLWESub for Module<BE>
where Self: ModuleN + VecZnxSub + VecZnxCopy + VecZnxNegateInplace + VecZnxSubInplace + VecZnxSubNegateInplace,

Implementors§