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
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::shortint::backward_compatibility::parameters::list_compression::{
    ClassicCompressionParametersVersions, CompressionParametersVersions,
    MultiBitCompressionParametersVersions,
};
use crate::shortint::parameters::{
    CiphertextModulusLog, DecompositionBaseLog, DecompositionLevelCount, DynamicDistribution,
    GlweDimension, LweBskGroupingFactor, LweCiphertextCount, PolynomialSize,
};
use serde::{Deserialize, Serialize};
use std::fmt::Debug;
use tfhe_versionable::Versionize;

#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize, Versionize)]
#[versionize(CompressionParametersVersions)]
pub enum CompressionParameters {
    Classic(ClassicCompressionParameters),
    MultiBit(MultiBitCompressionParameters),
}

impl CompressionParameters {
    pub fn br_level(&self) -> DecompositionLevelCount {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.br_level
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.br_level
            }
        }
    }
    pub fn br_base_log(&self) -> DecompositionBaseLog {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.br_base_log
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.br_base_log
            }
        }
    }
    pub fn packing_ks_level(&self) -> DecompositionLevelCount {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.packing_ks_level
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.packing_ks_level
            }
        }
    }
    pub fn packing_ks_base_log(&self) -> DecompositionBaseLog {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.packing_ks_base_log
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.packing_ks_base_log
            }
        }
    }
    pub fn packing_ks_polynomial_size(&self) -> PolynomialSize {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.packing_ks_polynomial_size
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.packing_ks_polynomial_size
            }
        }
    }
    pub fn packing_ks_glwe_dimension(&self) -> GlweDimension {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.packing_ks_glwe_dimension
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.packing_ks_glwe_dimension
            }
        }
    }
    pub fn lwe_per_glwe(&self) -> LweCiphertextCount {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.lwe_per_glwe
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.lwe_per_glwe
            }
        }
    }
    pub fn storage_log_modulus(&self) -> CiphertextModulusLog {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.storage_log_modulus
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.storage_log_modulus
            }
        }
    }
    pub fn packing_ks_key_noise_distribution(&self) -> DynamicDistribution<u64> {
        match self {
            Self::Classic(classic_compression_parameters) => {
                classic_compression_parameters.packing_ks_key_noise_distribution
            }
            Self::MultiBit(multi_bit_compression_parameters) => {
                multi_bit_compression_parameters.packing_ks_key_noise_distribution
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize, Versionize)]
#[versionize(ClassicCompressionParametersVersions)]
pub struct ClassicCompressionParameters {
    pub br_level: DecompositionLevelCount,
    pub br_base_log: DecompositionBaseLog,
    pub packing_ks_level: DecompositionLevelCount,
    pub packing_ks_base_log: DecompositionBaseLog,
    pub packing_ks_polynomial_size: PolynomialSize,
    pub packing_ks_glwe_dimension: GlweDimension,
    pub lwe_per_glwe: LweCiphertextCount,
    pub storage_log_modulus: CiphertextModulusLog,
    pub packing_ks_key_noise_distribution: DynamicDistribution<u64>,
}

#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize, Versionize)]
#[versionize(MultiBitCompressionParametersVersions)]
pub struct MultiBitCompressionParameters {
    pub br_level: DecompositionLevelCount,
    pub br_base_log: DecompositionBaseLog,
    pub packing_ks_level: DecompositionLevelCount,
    pub packing_ks_base_log: DecompositionBaseLog,
    pub packing_ks_polynomial_size: PolynomialSize,
    pub packing_ks_glwe_dimension: GlweDimension,
    pub lwe_per_glwe: LweCiphertextCount,
    pub storage_log_modulus: CiphertextModulusLog,
    pub packing_ks_key_noise_distribution: DynamicDistribution<u64>,
    pub decompression_grouping_factor: LweBskGroupingFactor,
}