tfhe 1.6.0

TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use super::NB_TESTS;
use crate::shortint::keycache::KEY_CACHE;
use crate::shortint::parameters::test_params::*;
use crate::shortint::parameters::NoiseLevel;
use crate::shortint::server_key::tests::parameterized_test::create_parameterized_test;
use rand::Rng;

create_parameterized_test!(shortint_modulus_switch_compression);

fn shortint_modulus_switch_compression<P>(param: P)
where
    P: Into<TestParameters>,
{
    let keys = KEY_CACHE.get_from_param(param);
    let (cks, sks) = (keys.client_key(), keys.server_key());

    let mut rng = rand::thread_rng();

    let modulus_sup = cks.parameters().message_modulus().0 * cks.parameters().carry_modulus().0;

    let modulus = cks.parameters().message_modulus().0;

    for _ in 0..NB_TESTS {
        let clear = rng.gen::<u64>() % modulus_sup;

        let ctxt = cks.unchecked_encrypt(clear);

        let compressed_ct = sks.switch_modulus_and_compress(&ctxt);

        {
            let decompressed_ct = sks.decompress(&compressed_ct);

            let dec = cks.decrypt_message_and_carry(&decompressed_ct);

            assert_eq!(clear, dec);

            assert_eq!(ctxt.degree, decompressed_ct.degree);
            assert_eq!(decompressed_ct.noise_level(), NoiseLevel::NOMINAL);
            assert_eq!(ctxt.message_modulus, decompressed_ct.message_modulus);
            assert_eq!(ctxt.carry_modulus, decompressed_ct.carry_modulus);
            assert_eq!(ctxt.atomic_pattern, decompressed_ct.atomic_pattern);
        }
        {
            let lookup_table = sks.generate_msg_lookup_table(|a| a + 1, ctxt.message_modulus);

            let decompressed_ct =
                sks.decompress_and_apply_lookup_table(&compressed_ct, &lookup_table);

            let dec = cks.decrypt(&decompressed_ct);

            assert_eq!((clear + 1) % modulus, dec % modulus);

            assert_eq!(decompressed_ct.noise_level(), NoiseLevel::NOMINAL);
            assert_eq!(ctxt.message_modulus, decompressed_ct.message_modulus);
            assert_eq!(ctxt.carry_modulus, decompressed_ct.carry_modulus);
            assert_eq!(ctxt.atomic_pattern, decompressed_ct.atomic_pattern);
        }
    }
}