GLWESub

poulpy_core

Trait GLWESub 

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

Implementors§