tfhe 1.6.1

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Module with the definition of the Ciphertext.
use super::super::parameters::CiphertextConformanceParams;
use super::common::*;
use super::standard::Ciphertext;
use crate::conformance::ParameterSetConformant;
use crate::core_crypto::entities::*;
use crate::shortint::backward_compatibility::ciphertext::CompressedCiphertextVersions;
use crate::shortint::parameters::{AtomicPatternKind, CarryModulus, MessageModulus};
use serde::{Deserialize, Serialize};
use tfhe_versionable::Versionize;

/// A structure representing a compressed shortint ciphertext.
/// It is used to homomorphically evaluate a shortint circuits.
/// Internally, it uses a LWE ciphertext.
#[derive(Clone, Serialize, Deserialize, Versionize)]
#[versionize(CompressedCiphertextVersions)]
pub struct CompressedCiphertext {
    pub ct: SeededLweCiphertext<u64>,
    pub degree: Degree,
    pub message_modulus: MessageModulus,
    pub carry_modulus: CarryModulus,
    pub atomic_pattern: AtomicPatternKind,
    pub noise_level: NoiseLevel,
}

impl ParameterSetConformant for CompressedCiphertext {
    type ParameterSet = CiphertextConformanceParams;

    fn is_conformant(&self, param: &CiphertextConformanceParams) -> bool {
        let Self {
            ct,
            degree,
            message_modulus,
            carry_modulus,
            atomic_pattern,
            noise_level,
        } = self;

        ct.is_conformant(&param.ct_params)
            && *message_modulus == param.message_modulus
            && *carry_modulus == param.carry_modulus
            && *atomic_pattern == param.atomic_pattern
            && *degree == param.degree
            && *noise_level == param.noise_level
    }
}

impl CompressedCiphertext {
    pub fn decompress(&self) -> Ciphertext {
        let Self {
            ct,
            degree,
            message_modulus,
            carry_modulus,
            atomic_pattern,
            noise_level,
        } = self;

        Ciphertext::new(
            ct.clone().decompress_into_lwe_ciphertext(),
            *degree,
            *noise_level,
            *message_modulus,
            *carry_modulus,
            *atomic_pattern,
        )
    }

    /// Deconstruct a [`CompressedCiphertext`] into its constituents.
    pub fn into_raw_parts(
        self,
    ) -> (
        SeededLweCiphertext<u64>,
        Degree,
        MessageModulus,
        CarryModulus,
        AtomicPatternKind,
        NoiseLevel,
    ) {
        let Self {
            ct,
            degree,
            message_modulus,
            carry_modulus,
            atomic_pattern,
            noise_level,
        } = self;

        (
            ct,
            degree,
            message_modulus,
            carry_modulus,
            atomic_pattern,
            noise_level,
        )
    }

    /// Construct a [`CompressedCiphertext`] from its constituents.
    pub fn from_raw_parts(
        ct: SeededLweCiphertext<u64>,
        degree: Degree,
        message_modulus: MessageModulus,
        carry_modulus: CarryModulus,
        atomic_pattern: AtomicPatternKind,
        noise_level: NoiseLevel,
    ) -> Self {
        Self {
            ct,
            degree,
            message_modulus,
            carry_modulus,
            atomic_pattern,
            noise_level,
        }
    }
}