github/tfhe-rs
1
1
Fork 0
mirror of https://github.com/zama-ai/tfhe-rs.git synced 2026-01-08 22:28:01 -05:00
Code Issues Packages Projects Releases Wiki Activity

chore(backward): add multi bit support

Browse Source
This commit is contained in:
Mayeul@Zama
2025-08-08 11:45:49 +02:00
committed by Nicolas Sarlin
parent b3f1a85e1d
commit c8a9105953
12 changed files with 782 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
tests/backward_compatibility/high_level_api.rs
View File

@@ -10,9 +10,7 @@ use tfhe::shortint::parameters::{
};
#[cfg(feature = "zk-pok")]
use tfhe::shortint::prelude::LweDimension;
use tfhe::shortint::{
AtomicPatternParameters, CarryModulus, CiphertextModulus, MessageModulus, PBSParameters,
};
use tfhe::shortint::{AtomicPatternParameters, CarryModulus, CiphertextModulus, MessageModulus};
#[cfg(feature = "zk-pok")]
use tfhe::zk::{CompactPkeCrs, CompactPkeCrsConformanceParams};
use tfhe::{
@@ -38,7 +36,7 @@ use tfhe_versionable::Unversionize;
fn load_hl_params(test_params: &TestParameterSet) -> AtomicPatternParameters {
let pbs_params = load_params(test_params);
PBSParameters::PBS(pbs_params).into()
pbs_params.into()
}
/// Test HL ciphertext: loads the ciphertext and compare the decrypted value to the one in the

186
tests/backward_compatibility/shortint.rs
View File

@@ -2,14 +2,16 @@ use std::path::Path;
use tfhe::core_crypto::prelude::{
LweCiphertextCount, NoiseEstimationMeasureBound, RSigmaFactor, TUniform, Variance,
};
use tfhe::shortint::parameters::{ModulusSwitchNoiseReductionParams, ModulusSwitchType};
use tfhe::shortint::parameters::{
LweBskGroupingFactor, ModulusSwitchNoiseReductionParams, ModulusSwitchType,
};
use tfhe_backward_compat_data::load::{
load_versioned_auxiliary, DataFormat, TestFailure, TestResult, TestSuccess,
};
use tfhe_backward_compat_data::{
ShortintCiphertextTest, ShortintClientKeyTest, TestDistribution, TestMetadata,
TestModulusSwitchNoiseReductionParams, TestModulusSwitchType, TestParameterSet, TestType,
Testcase,
ShortintCiphertextTest, ShortintClientKeyTest, TestClassicParameterSet, TestDistribution,
TestMetadata, TestModulusSwitchNoiseReductionParams, TestModulusSwitchType,
TestMultiBitParameterSet, TestParameterSet, TestType, Testcase,
};
use tfhe::shortint::parameters::{
@@ -18,7 +20,8 @@ use tfhe::shortint::parameters::{
};
use tfhe::shortint::{
CarryModulus, Ciphertext, CiphertextModulus, ClassicPBSParameters, ClientKey,
EncryptionKeyChoice, MaxNoiseLevel, MessageModulus, PBSParameters, ShortintParameterSet,
EncryptionKeyChoice, MaxNoiseLevel, MessageModulus, MultiBitPBSParameters, PBSParameters,
ShortintParameterSet,
};
use tfhe_versionable::Unversionize;
@@ -26,69 +29,118 @@ use crate::{load_and_unversionize, TestedModule};
/// Converts test parameters metadata that are independent of any tfhe-rs version and use only
/// built-in types into parameters suitable for the currently tested version.
pub fn load_params(test_params: &TestParameterSet) -> ClassicPBSParameters {
let TestParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
modulus_switch_noise_reduction_params,
} = test_params;
pub fn load_params(test_params: &TestParameterSet) -> PBSParameters {
match test_params {
TestParameterSet::TestClassicParameterSet(TestClassicParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
modulus_switch_noise_reduction_params,
}) => {
let modulus_switch_noise_reduction_params = match modulus_switch_noise_reduction_params
{
TestModulusSwitchType::Standard => ModulusSwitchType::Standard,
TestModulusSwitchType::DriftTechniqueNoiseReduction(
TestModulusSwitchNoiseReductionParams {
modulus_switch_zeros_count,
ms_bound,
ms_r_sigma_factor,
ms_input_variance,
},
) => ModulusSwitchType::DriftTechniqueNoiseReduction(
ModulusSwitchNoiseReductionParams {
modulus_switch_zeros_count: LweCiphertextCount(*modulus_switch_zeros_count),
ms_bound: NoiseEstimationMeasureBound(*ms_bound),
ms_r_sigma_factor: RSigmaFactor(*ms_r_sigma_factor),
ms_input_variance: Variance(*ms_input_variance),
},
),
TestModulusSwitchType::CenteredMeanNoiseReduction => {
ModulusSwitchType::CenteredMeanNoiseReduction
}
};
let modulus_switch_noise_reduction_params = match modulus_switch_noise_reduction_params {
TestModulusSwitchType::Standard => ModulusSwitchType::Standard,
TestModulusSwitchType::DriftTechniqueNoiseReduction(
TestModulusSwitchNoiseReductionParams {
modulus_switch_zeros_count,
ms_bound,
ms_r_sigma_factor,
ms_input_variance,
},
) => ModulusSwitchType::DriftTechniqueNoiseReduction(ModulusSwitchNoiseReductionParams {
modulus_switch_zeros_count: LweCiphertextCount(*modulus_switch_zeros_count),
ms_bound: NoiseEstimationMeasureBound(*ms_bound),
ms_r_sigma_factor: RSigmaFactor(*ms_r_sigma_factor),
ms_input_variance: Variance(*ms_input_variance),
}),
TestModulusSwitchType::CenteredMeanNoiseReduction => {
ModulusSwitchType::CenteredMeanNoiseReduction
}
};
ClassicPBSParameters {
lwe_dimension: LweDimension(*lwe_dimension),
glwe_dimension: GlweDimension(*glwe_dimension),
polynomial_size: PolynomialSize(*polynomial_size),
lwe_noise_distribution: convert_distribution(lwe_noise_distribution),
glwe_noise_distribution: convert_distribution(glwe_noise_distribution),
pbs_base_log: DecompositionBaseLog(*pbs_base_log),
pbs_level: DecompositionLevelCount(*pbs_level),
ks_base_log: DecompositionBaseLog(*ks_base_log),
ks_level: DecompositionLevelCount(*ks_level),
message_modulus: MessageModulus(*message_modulus as u64),
carry_modulus: CarryModulus(*carry_modulus as u64),
max_noise_level: MaxNoiseLevel::new(*max_noise_level as u64),
log2_p_fail: *log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(*ciphertext_modulus).unwrap(),
encryption_key_choice: {
match encryption_key_choice.as_ref() {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
ClassicPBSParameters {
lwe_dimension: LweDimension(*lwe_dimension),
glwe_dimension: GlweDimension(*glwe_dimension),
polynomial_size: PolynomialSize(*polynomial_size),
lwe_noise_distribution: convert_distribution(lwe_noise_distribution),
glwe_noise_distribution: convert_distribution(glwe_noise_distribution),
pbs_base_log: DecompositionBaseLog(*pbs_base_log),
pbs_level: DecompositionLevelCount(*pbs_level),
ks_base_log: DecompositionBaseLog(*ks_base_log),
ks_level: DecompositionLevelCount(*ks_level),
message_modulus: MessageModulus(*message_modulus as u64),
carry_modulus: CarryModulus(*carry_modulus as u64),
max_noise_level: MaxNoiseLevel::new(*max_noise_level as u64),
log2_p_fail: *log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(*ciphertext_modulus).unwrap(),
encryption_key_choice: {
match encryption_key_choice.as_ref() {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
}
},
modulus_switch_noise_reduction_params,
}
},
modulus_switch_noise_reduction_params,
.into()
}
TestParameterSet::TestMultiBitParameterSet(TestMultiBitParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
grouping_factor,
}) => MultiBitPBSParameters {
lwe_dimension: LweDimension(*lwe_dimension),
glwe_dimension: GlweDimension(*glwe_dimension),
polynomial_size: PolynomialSize(*polynomial_size),
lwe_noise_distribution: convert_distribution(lwe_noise_distribution),
glwe_noise_distribution: convert_distribution(glwe_noise_distribution),
pbs_base_log: DecompositionBaseLog(*pbs_base_log),
pbs_level: DecompositionLevelCount(*pbs_level),
ks_base_log: DecompositionBaseLog(*ks_base_log),
ks_level: DecompositionLevelCount(*ks_level),
message_modulus: MessageModulus(*message_modulus as u64),
carry_modulus: CarryModulus(*carry_modulus as u64),
max_noise_level: MaxNoiseLevel::new(*max_noise_level as u64),
log2_p_fail: *log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(*ciphertext_modulus).unwrap(),
encryption_key_choice: {
match encryption_key_choice.as_ref() {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
}
},
grouping_factor: LweBskGroupingFactor(*grouping_factor),
deterministic_execution: false,
}
.into(),
}
}
@@ -104,7 +156,7 @@ fn convert_distribution(value: &TestDistribution) -> DynamicDistribution<u64> {
}
fn load_shortint_params(test_params: &TestParameterSet) -> ShortintParameterSet {
ShortintParameterSet::new_pbs_param_set(PBSParameters::PBS(load_params(test_params)))
ShortintParameterSet::new_pbs_param_set(load_params(test_params))
}
pub fn test_shortint_ciphertext(

24
utils/tfhe-backward-compat-data/data/high_level_api.ron
View File

@@ -4,7 +4,7 @@
tfhe_module: "high_level_api",
metadata: HlClientKey((
test_filename: "batch_1_client_key",
parameters: (
parameters: TestClassicParameterSet((
lwe_dimension: 887,
glwe_dimension: 1,
polynomial_size: 2048,
@@ -25,7 +25,7 @@
log2_p_fail: -64.138,
encryption_key_choice: "big",
modulus_switch_noise_reduction_params: Standard,
),
)),
)),
),
(
@@ -298,7 +298,7 @@
tfhe_module: "high_level_api",
metadata: HlClientKey((
test_filename: "client_key_with_compression",
parameters: (
parameters: TestClassicParameterSet((
lwe_dimension: 887,
glwe_dimension: 1,
polynomial_size: 2048,
@@ -319,7 +319,7 @@
log2_p_fail: -64.138,
encryption_key_choice: "big",
modulus_switch_noise_reduction_params: Standard,
),
)),
)),
),
(
@@ -327,7 +327,7 @@
tfhe_module: "high_level_api",
metadata: HlClientKey((
test_filename: "client_key",
parameters: (
parameters: TestClassicParameterSet((
lwe_dimension: 887,
glwe_dimension: 1,
polynomial_size: 2048,
@@ -348,7 +348,7 @@
log2_p_fail: -64.138,
encryption_key_choice: "big",
modulus_switch_noise_reduction_params: Standard,
),
)),
)),
),
(
@@ -413,7 +413,7 @@
tfhe_module: "high_level_api",
metadata: HlClientKey((
test_filename: "client_key_ms_noise_reduction",
parameters: (
parameters: TestClassicParameterSet((
lwe_dimension: 2,
glwe_dimension: 1,
polynomial_size: 2048,
@@ -439,7 +439,7 @@
ms_r_sigma_factor: 13.179852282053789,
ms_input_variance: 0.000000263039184094559,
)),
),
)),
)),
),
(
@@ -469,7 +469,7 @@
tfhe_module: "high_level_api",
metadata: HlClientKey((
test_filename: "client_key_with_noise_squashing",
parameters: (
parameters: TestClassicParameterSet((
lwe_dimension: 2,
glwe_dimension: 1,
polynomial_size: 2048,
@@ -495,7 +495,7 @@
ms_r_sigma_factor: 13.179852282053789,
ms_input_variance: 0.000000263039184094559,
)),
),
)),
)),
),
(
@@ -583,7 +583,7 @@
tfhe_module: "high_level_api",
metadata: HlClientKey((
test_filename: "client_key_ms_mean_compensation",
parameters: (
parameters: TestClassicParameterSet((
lwe_dimension: 2,
glwe_dimension: 1,
polynomial_size: 2048,
@@ -604,7 +604,7 @@
log2_p_fail: -129.15284804376165,
encryption_key_choice: "big",
modulus_switch_noise_reduction_params: CenteredMeanNoiseReduction,
),
)),
)),
),
(

4
utils/tfhe-backward-compat-data/data/shortint.ron
View File

@@ -4,7 +4,7 @@
tfhe_module: "shortint",
metadata: ShortintClientKey((
test_filename: "client_key",
parameters: (
parameters: TestClassicParameterSet((
lwe_dimension: 761,
glwe_dimension: 1,
polynomial_size: 2048,
@@ -25,7 +25,7 @@
log2_p_fail: -40.05,
encryption_key_choice: "big",
modulus_switch_noise_reduction_params: Standard,
),
)),
)),
),
(

71
utils/tfhe-backward-compat-data/src/data_0_10.rs
View File

@@ -3,8 +3,8 @@ use crate::generate::{
VALID_TEST_PARAMS_TUNIFORM_COMPRESSION,
};
use crate::{
HlClientKeyTest, HlServerKeyTest, TestCompressionParameterSet, TestDistribution, TestMetadata,
TestParameterSet, HL_MODULE_NAME,
HlClientKeyTest, HlServerKeyTest, TestClassicParameterSet, TestCompressionParameterSet,
TestDistribution, TestMetadata, TestMultiBitParameterSet, TestParameterSet, HL_MODULE_NAME,
};
use std::borrow::Cow;
use std::fs::create_dir_all;
@@ -16,8 +16,8 @@ use tfhe_0_10::shortint::engine::ShortintEngine;
use tfhe_0_10::shortint::parameters::{
CarryModulus, CiphertextModulus, ClassicPBSParameters, CompressionParameters,
DecompositionBaseLog, DecompositionLevelCount, DynamicDistribution, EncryptionKeyChoice,
GlweDimension, LweDimension, MaxNoiseLevel, MessageModulus, PBSParameters, PolynomialSize,
StandardDev,
GlweDimension, LweBskGroupingFactor, LweDimension, MaxNoiseLevel, MessageModulus,
MultiBitPBSParameters, PBSParameters, PolynomialSize, StandardDev,
};
use tfhe_0_10::{CompressedServerKey, Seed};
@@ -40,8 +40,8 @@ impl From<TestDistribution> for DynamicDistribution<u64> {
}
}
impl From<TestParameterSet> for ClassicPBSParameters {
fn from(value: TestParameterSet) -> Self {
impl From<TestClassicParameterSet> for ClassicPBSParameters {
fn from(value: TestClassicParameterSet) -> Self {
ClassicPBSParameters {
lwe_dimension: LweDimension(value.lwe_dimension),
glwe_dimension: GlweDimension(value.glwe_dimension),
@@ -68,10 +68,65 @@ impl From<TestParameterSet> for ClassicPBSParameters {
}
}
impl From<TestMultiBitParameterSet> for MultiBitPBSParameters {
fn from(value: TestMultiBitParameterSet) -> Self {
let TestMultiBitParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
grouping_factor,
} = value;
MultiBitPBSParameters {
lwe_dimension: LweDimension(lwe_dimension),
glwe_dimension: GlweDimension(glwe_dimension),
polynomial_size: PolynomialSize(polynomial_size),
lwe_noise_distribution: lwe_noise_distribution.into(),
glwe_noise_distribution: glwe_noise_distribution.into(),
pbs_base_log: DecompositionBaseLog(pbs_base_log),
pbs_level: DecompositionLevelCount(pbs_level),
ks_base_log: DecompositionBaseLog(ks_base_log),
ks_level: DecompositionLevelCount(ks_level),
message_modulus: MessageModulus(message_modulus),
carry_modulus: CarryModulus(carry_modulus),
max_noise_level: MaxNoiseLevel::new(max_noise_level),
log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(ciphertext_modulus).unwrap(),
encryption_key_choice: {
match &*encryption_key_choice {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
}
},
grouping_factor: LweBskGroupingFactor(grouping_factor),
deterministic_execution: false,
}
}
}
impl From<TestParameterSet> for PBSParameters {
fn from(value: TestParameterSet) -> Self {
let tmp: ClassicPBSParameters = value.into();
tmp.into()
match value {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
PBSParameters::PBS(test_classic_parameter_set.into())
}
TestParameterSet::TestMultiBitParameterSet(test_parameter_set_multi_bit) => {
PBSParameters::MultiBitPBS(test_parameter_set_multi_bit.into())
}
}
}
}

83
utils/tfhe-backward-compat-data/src/data_0_11.rs
View File

@@ -4,7 +4,8 @@ use crate::generate::{
};
use crate::{
DataKind, HlClientKeyTest, HlHeterogeneousCiphertextListTest, PkeZkProofAuxiliaryInfo,
TestDistribution, TestMetadata, TestParameterSet, ZkPkePublicParamsTest, HL_MODULE_NAME,
TestClassicParameterSet, TestDistribution, TestMetadata, TestMultiBitParameterSet,
TestParameterSet, ZkPkePublicParamsTest, HL_MODULE_NAME,
};
use std::borrow::Cow;
use std::fs::create_dir_all;
@@ -15,8 +16,9 @@ use tfhe_0_11::core_crypto::prelude::{LweCiphertextCount, TUniform};
use tfhe_0_11::shortint::engine::ShortintEngine;
use tfhe_0_11::shortint::parameters::{
CarryModulus, CiphertextModulus, ClassicPBSParameters, DecompositionBaseLog,
DecompositionLevelCount, DynamicDistribution, EncryptionKeyChoice, GlweDimension, LweDimension,
MaxNoiseLevel, MessageModulus, PBSParameters, PolynomialSize, StandardDev,
DecompositionLevelCount, DynamicDistribution, EncryptionKeyChoice, GlweDimension,
LweBskGroupingFactor, LweDimension, MaxNoiseLevel, MessageModulus, MultiBitPBSParameters,
PBSParameters, PolynomialSize, StandardDev,
};
use tfhe_0_11::zk::{CompactPkeCrs, ZkComputeLoad, ZkMSBZeroPaddingBitCount};
use tfhe_0_11::{
@@ -48,8 +50,8 @@ impl From<TestDistribution> for DynamicDistribution<u64> {
}
}
impl From<TestParameterSet> for ClassicPBSParameters {
fn from(value: TestParameterSet) -> Self {
impl From<TestClassicParameterSet> for ClassicPBSParameters {
fn from(value: TestClassicParameterSet) -> Self {
ClassicPBSParameters {
lwe_dimension: LweDimension(value.lwe_dimension),
glwe_dimension: GlweDimension(value.glwe_dimension),
@@ -76,10 +78,65 @@ impl From<TestParameterSet> for ClassicPBSParameters {
}
}
impl From<TestMultiBitParameterSet> for MultiBitPBSParameters {
fn from(value: TestMultiBitParameterSet) -> Self {
let TestMultiBitParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
grouping_factor,
} = value;
MultiBitPBSParameters {
lwe_dimension: LweDimension(lwe_dimension),
glwe_dimension: GlweDimension(glwe_dimension),
polynomial_size: PolynomialSize(polynomial_size),
lwe_noise_distribution: lwe_noise_distribution.into(),
glwe_noise_distribution: glwe_noise_distribution.into(),
pbs_base_log: DecompositionBaseLog(pbs_base_log),
pbs_level: DecompositionLevelCount(pbs_level),
ks_base_log: DecompositionBaseLog(ks_base_log),
ks_level: DecompositionLevelCount(ks_level),
message_modulus: MessageModulus(message_modulus as u64),
carry_modulus: CarryModulus(carry_modulus as u64),
max_noise_level: MaxNoiseLevel::new(max_noise_level as u64),
log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(ciphertext_modulus).unwrap(),
encryption_key_choice: {
match &*encryption_key_choice {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
}
},
grouping_factor: LweBskGroupingFactor(grouping_factor),
deterministic_execution: false,
}
}
}
impl From<TestParameterSet> for PBSParameters {
fn from(value: TestParameterSet) -> Self {
let tmp: ClassicPBSParameters = value.into();
tmp.into()
match value {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
PBSParameters::PBS(test_classic_parameter_set.into())
}
TestParameterSet::TestMultiBitParameterSet(test_parameter_set_multi_bit) => {
PBSParameters::MultiBitPBS(test_parameter_set_multi_bit.into())
}
}
}
}
@@ -91,16 +148,16 @@ const HL_CLIENTKEY_TEST: HlClientKeyTest = HlClientKeyTest {
// The CRS is structurally equivalent to the public params type so we reuse the test
const ZK_PKE_CRS_TEST: ZkPkePublicParamsTest = ZkPkePublicParamsTest {
test_filename: Cow::Borrowed("zk_pke_crs"),
lwe_dimension: VALID_TEST_PARAMS_TUNIFORM.polynomial_size
* VALID_TEST_PARAMS_TUNIFORM.glwe_dimension, // Lwe dimension of the "big" key is glwe dimension * polynomial size
lwe_dimension: VALID_TEST_PARAMS_TUNIFORM.polynomial_size()
* VALID_TEST_PARAMS_TUNIFORM.glwe_dimension(), // Lwe dimension of the "big" key is glwe dimension * polynomial size
max_num_cleartext: 16,
noise_bound: match VALID_TEST_PARAMS_TUNIFORM.lwe_noise_distribution {
noise_bound: match VALID_TEST_PARAMS_TUNIFORM.lwe_noise_distribution() {
TestDistribution::Gaussian { .. } => unreachable!(),
TestDistribution::TUniform { bound_log2 } => bound_log2 as usize,
},
ciphertext_modulus: VALID_TEST_PARAMS_TUNIFORM.ciphertext_modulus,
plaintext_modulus: VALID_TEST_PARAMS_TUNIFORM.message_modulus
* VALID_TEST_PARAMS_TUNIFORM.carry_modulus
ciphertext_modulus: VALID_TEST_PARAMS_TUNIFORM.ciphertext_modulus(),
plaintext_modulus: VALID_TEST_PARAMS_TUNIFORM.message_modulus()
* VALID_TEST_PARAMS_TUNIFORM.carry_modulus()
* 2, // *2 for padding bit
padding_bit_count: 1,
};

83
utils/tfhe-backward-compat-data/src/data_0_8.rs
View File

@@ -14,9 +14,10 @@ use tfhe_0_8::integer::parameters::{
use tfhe_0_8::prelude::*;
use tfhe_0_8::shortint::engine::ShortintEngine;
use tfhe_0_8::shortint::parameters::list_compression::CompressionParameters;
use tfhe_0_8::shortint::parameters::LweBskGroupingFactor;
use tfhe_0_8::shortint::{
CarryModulus, CiphertextModulus, ClassicPBSParameters, EncryptionKeyChoice, MaxNoiseLevel,
MessageModulus, PBSParameters,
MessageModulus, MultiBitPBSParameters, PBSParameters,
};
use tfhe_0_8::zk::{CompactPkeCrs, ZkComputeLoad, ZkMSBZeroPaddingBitCount};
use tfhe_0_8::{
@@ -35,8 +36,9 @@ use crate::{
DataKind, HlBoolCiphertextTest, HlCiphertextTest, HlClientKeyTest,
HlHeterogeneousCiphertextListTest, HlPublicKeyTest, HlSignedCiphertextTest,
PkeZkProofAuxiliaryInfo, ShortintCiphertextTest, ShortintClientKeyTest,
TestCompressionParameterSet, TestDistribution, TestMetadata, TestParameterSet,
ZkPkePublicParamsTest, HL_MODULE_NAME, SHORTINT_MODULE_NAME,
TestClassicParameterSet, TestCompressionParameterSet, TestDistribution, TestMetadata,
TestMultiBitParameterSet, TestParameterSet, ZkPkePublicParamsTest, HL_MODULE_NAME,
SHORTINT_MODULE_NAME,
};
macro_rules! store_versioned_test {
@@ -64,8 +66,8 @@ impl From<TestDistribution> for DynamicDistribution<u64> {
}
}
impl From<TestParameterSet> for ClassicPBSParameters {
fn from(value: TestParameterSet) -> Self {
impl From<TestClassicParameterSet> for ClassicPBSParameters {
fn from(value: TestClassicParameterSet) -> Self {
ClassicPBSParameters {
lwe_dimension: LweDimension(value.lwe_dimension),
glwe_dimension: GlweDimension(value.glwe_dimension),
@@ -92,10 +94,65 @@ impl From<TestParameterSet> for ClassicPBSParameters {
}
}
impl From<TestMultiBitParameterSet> for MultiBitPBSParameters {
fn from(value: TestMultiBitParameterSet) -> Self {
let TestMultiBitParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
grouping_factor,
} = value;
MultiBitPBSParameters {
lwe_dimension: LweDimension(lwe_dimension),
glwe_dimension: GlweDimension(glwe_dimension),
polynomial_size: PolynomialSize(polynomial_size),
lwe_noise_distribution: lwe_noise_distribution.into(),
glwe_noise_distribution: glwe_noise_distribution.into(),
pbs_base_log: DecompositionBaseLog(pbs_base_log),
pbs_level: DecompositionLevelCount(pbs_level),
ks_base_log: DecompositionBaseLog(ks_base_log),
ks_level: DecompositionLevelCount(ks_level),
message_modulus: MessageModulus(message_modulus),
carry_modulus: CarryModulus(carry_modulus),
max_noise_level: MaxNoiseLevel::new(max_noise_level),
log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(ciphertext_modulus).unwrap(),
encryption_key_choice: {
match &*encryption_key_choice {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
}
},
grouping_factor: LweBskGroupingFactor(grouping_factor),
deterministic_execution: false,
}
}
}
impl From<TestParameterSet> for PBSParameters {
fn from(value: TestParameterSet) -> Self {
let classic_pbs: ClassicPBSParameters = value.into();
classic_pbs.into()
match value {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
PBSParameters::PBS(test_classic_parameter_set.into())
}
TestParameterSet::TestMultiBitParameterSet(test_parameter_set_multi_bit) => {
PBSParameters::MultiBitPBS(test_parameter_set_multi_bit.into())
}
}
}
}
@@ -330,16 +387,16 @@ const HL_PROVEN_COMPACTLIST_TEST: HlHeterogeneousCiphertextListTest =
const ZK_PKE_PUBLIC_PARAMS_TEST: ZkPkePublicParamsTest = ZkPkePublicParamsTest {
test_filename: Cow::Borrowed("zk_pke_public_params"),
lwe_dimension: VALID_TEST_PARAMS_TUNIFORM.polynomial_size
* VALID_TEST_PARAMS_TUNIFORM.glwe_dimension, // Lwe dimension of the "big" key is glwe dimension * polynomial size
lwe_dimension: VALID_TEST_PARAMS_TUNIFORM.polynomial_size()
* VALID_TEST_PARAMS_TUNIFORM.glwe_dimension(), // Lwe dimension of the "big" key is glwe dimension * polynomial size
max_num_cleartext: 16,
noise_bound: match VALID_TEST_PARAMS_TUNIFORM.lwe_noise_distribution {
noise_bound: match VALID_TEST_PARAMS_TUNIFORM.lwe_noise_distribution() {
TestDistribution::Gaussian { .. } => unreachable!(),
TestDistribution::TUniform { bound_log2 } => bound_log2 as usize,
},
ciphertext_modulus: VALID_TEST_PARAMS_TUNIFORM.ciphertext_modulus,
plaintext_modulus: VALID_TEST_PARAMS_TUNIFORM.message_modulus
* VALID_TEST_PARAMS_TUNIFORM.carry_modulus
ciphertext_modulus: VALID_TEST_PARAMS_TUNIFORM.ciphertext_modulus(),
plaintext_modulus: VALID_TEST_PARAMS_TUNIFORM.message_modulus()
* VALID_TEST_PARAMS_TUNIFORM.carry_modulus()
* 2, // *2 for padding bit
padding_bit_count: 1,
};

88
utils/tfhe-backward-compat-data/src/data_1_0.rs
View File

@@ -3,9 +3,9 @@ use crate::generate::{
PRNG_SEED, VALID_TEST_PARAMS_TUNIFORM,
};
use crate::{
HlClientKeyTest, HlServerKeyTest, TestDistribution, TestMetadata,
TestModulusSwitchNoiseReductionParams, TestModulusSwitchType, TestParameterSet,
ZkPkePublicParamsTest, HL_MODULE_NAME,
HlClientKeyTest, HlServerKeyTest, TestClassicParameterSet, TestDistribution, TestMetadata,
TestModulusSwitchNoiseReductionParams, TestModulusSwitchType, TestMultiBitParameterSet,
TestParameterSet, ZkPkePublicParamsTest, HL_MODULE_NAME,
};
use std::borrow::Cow;
use std::fs::create_dir_all;
@@ -18,9 +18,10 @@ use tfhe_1_0::core_crypto::prelude::{
use tfhe_1_0::shortint::engine::ShortintEngine;
use tfhe_1_0::shortint::parameters::{
CarryModulus, CiphertextModulus, ClassicPBSParameters, DecompositionBaseLog,
DecompositionLevelCount, DynamicDistribution, EncryptionKeyChoice, GlweDimension, LweDimension,
MaxNoiseLevel, MessageModulus, ModulusSwitchNoiseReductionParams, PBSParameters,
PolynomialSize, StandardDev,
DecompositionLevelCount, DynamicDistribution, EncryptionKeyChoice, GlweDimension,
LweBskGroupingFactor, LweDimension, MaxNoiseLevel, MessageModulus,
ModulusSwitchNoiseReductionParams, MultiBitPBSParameters, PBSParameters, PolynomialSize,
StandardDev,
};
use tfhe_1_0::zk::{CompactPkeCrs, ZkMSBZeroPaddingBitCount};
use tfhe_1_0::Seed;
@@ -62,8 +63,8 @@ impl From<TestModulusSwitchNoiseReductionParams> for ModulusSwitchNoiseReduction
}
}
impl From<TestParameterSet> for ClassicPBSParameters {
fn from(value: TestParameterSet) -> Self {
impl From<TestClassicParameterSet> for ClassicPBSParameters {
fn from(value: TestClassicParameterSet) -> Self {
let modulus_switch_noise_reduction_params =
match value.modulus_switch_noise_reduction_params {
TestModulusSwitchType::Standard => None,
@@ -100,10 +101,65 @@ impl From<TestParameterSet> for ClassicPBSParameters {
}
}
impl From<TestMultiBitParameterSet> for MultiBitPBSParameters {
fn from(value: TestMultiBitParameterSet) -> Self {
let TestMultiBitParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
grouping_factor,
} = value;
MultiBitPBSParameters {
lwe_dimension: LweDimension(lwe_dimension),
glwe_dimension: GlweDimension(glwe_dimension),
polynomial_size: PolynomialSize(polynomial_size),
lwe_noise_distribution: lwe_noise_distribution.into(),
glwe_noise_distribution: glwe_noise_distribution.into(),
pbs_base_log: DecompositionBaseLog(pbs_base_log),
pbs_level: DecompositionLevelCount(pbs_level),
ks_base_log: DecompositionBaseLog(ks_base_log),
ks_level: DecompositionLevelCount(ks_level),
message_modulus: MessageModulus(message_modulus as u64),
carry_modulus: CarryModulus(carry_modulus as u64),
max_noise_level: MaxNoiseLevel::new(max_noise_level as u64),
log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(ciphertext_modulus).unwrap(),
encryption_key_choice: {
match &*encryption_key_choice {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
}
},
grouping_factor: LweBskGroupingFactor(grouping_factor),
deterministic_execution: false,
}
}
}
impl From<TestParameterSet> for PBSParameters {
fn from(value: TestParameterSet) -> Self {
let tmp: ClassicPBSParameters = value.into();
tmp.into()
match value {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
PBSParameters::PBS(test_classic_parameter_set.into())
}
TestParameterSet::TestMultiBitParameterSet(test_parameter_set_multi_bit) => {
PBSParameters::MultiBitPBS(test_parameter_set_multi_bit.into())
}
}
}
}
@@ -120,16 +176,16 @@ const HL_SERVERKEY_MS_NOISE_REDUCTION_TEST: HlServerKeyTest = HlServerKeyTest {
const ZK_PKEV2_CRS_TEST: ZkPkePublicParamsTest = ZkPkePublicParamsTest {
test_filename: Cow::Borrowed("zk_pkev2_crs"),
lwe_dimension: VALID_TEST_PARAMS_TUNIFORM.polynomial_size
* VALID_TEST_PARAMS_TUNIFORM.glwe_dimension, // Lwe dimension of the "big" key is glwe dimension * polynomial size
lwe_dimension: VALID_TEST_PARAMS_TUNIFORM.polynomial_size()
* VALID_TEST_PARAMS_TUNIFORM.glwe_dimension(), // Lwe dimension of the "big" key is glwe dimension * polynomial size
max_num_cleartext: 16,
noise_bound: match VALID_TEST_PARAMS_TUNIFORM.lwe_noise_distribution {
noise_bound: match VALID_TEST_PARAMS_TUNIFORM.lwe_noise_distribution() {
TestDistribution::Gaussian { .. } => unreachable!(),
TestDistribution::TUniform { bound_log2 } => bound_log2 as usize,
},
ciphertext_modulus: VALID_TEST_PARAMS_TUNIFORM.ciphertext_modulus,
plaintext_modulus: VALID_TEST_PARAMS_TUNIFORM.message_modulus
* VALID_TEST_PARAMS_TUNIFORM.carry_modulus
ciphertext_modulus: VALID_TEST_PARAMS_TUNIFORM.ciphertext_modulus(),
plaintext_modulus: VALID_TEST_PARAMS_TUNIFORM.message_modulus()
* VALID_TEST_PARAMS_TUNIFORM.carry_modulus()
* 2, // *2 for padding bit
padding_bit_count: 1,
};

75
utils/tfhe-backward-compat-data/src/data_1_1.rs
View File

@@ -5,9 +5,10 @@ use crate::generate::{
};
use crate::{
HlClientKeyTest, HlServerKeyTest, HlSquashedNoiseBoolCiphertextTest,
HlSquashedNoiseSignedCiphertextTest, HlSquashedNoiseUnsignedCiphertextTest, TestDistribution,
TestMetadata, TestModulusSwitchNoiseReductionParams, TestModulusSwitchType,
TestNoiseSquashingParams, TestParameterSet, HL_MODULE_NAME,
HlSquashedNoiseSignedCiphertextTest, HlSquashedNoiseUnsignedCiphertextTest,
TestClassicParameterSet, TestDistribution, TestMetadata, TestModulusSwitchNoiseReductionParams,
TestModulusSwitchType, TestMultiBitParameterSet, TestNoiseSquashingParams, TestParameterSet,
HL_MODULE_NAME,
};
use std::borrow::Cow;
use std::fs::create_dir_all;
@@ -22,8 +23,9 @@ use tfhe_1_1::shortint::engine::ShortintEngine;
use tfhe_1_1::shortint::parameters::{
CarryModulus, CiphertextModulus, ClassicPBSParameters, CoreCiphertextModulus,
DecompositionBaseLog, DecompositionLevelCount, DynamicDistribution, EncryptionKeyChoice,
GlweDimension, LweDimension, MaxNoiseLevel, MessageModulus, ModulusSwitchNoiseReductionParams,
NoiseSquashingParameters, PBSParameters, PolynomialSize, StandardDev,
GlweDimension, LweBskGroupingFactor, LweDimension, MaxNoiseLevel, MessageModulus,
ModulusSwitchNoiseReductionParams, MultiBitPBSParameters, NoiseSquashingParameters,
PBSParameters, PolynomialSize, StandardDev,
};
use tfhe_1_1::{set_server_key, CompressedServerKey, FheBool, FheInt64, FheUint64, Seed};
@@ -64,8 +66,8 @@ impl From<TestModulusSwitchNoiseReductionParams> for ModulusSwitchNoiseReduction
}
}
impl From<TestParameterSet> for ClassicPBSParameters {
fn from(value: TestParameterSet) -> Self {
impl From<TestClassicParameterSet> for ClassicPBSParameters {
fn from(value: TestClassicParameterSet) -> Self {
let modulus_switch_noise_reduction_params =
match value.modulus_switch_noise_reduction_params {
TestModulusSwitchType::Standard => None,
@@ -102,10 +104,65 @@ impl From<TestParameterSet> for ClassicPBSParameters {
}
}
impl From<TestMultiBitParameterSet> for MultiBitPBSParameters {
fn from(value: TestMultiBitParameterSet) -> Self {
let TestMultiBitParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
grouping_factor,
} = value;
MultiBitPBSParameters {
lwe_dimension: LweDimension(lwe_dimension),
glwe_dimension: GlweDimension(glwe_dimension),
polynomial_size: PolynomialSize(polynomial_size),
lwe_noise_distribution: lwe_noise_distribution.into(),
glwe_noise_distribution: glwe_noise_distribution.into(),
pbs_base_log: DecompositionBaseLog(pbs_base_log),
pbs_level: DecompositionLevelCount(pbs_level),
ks_base_log: DecompositionBaseLog(ks_base_log),
ks_level: DecompositionLevelCount(ks_level),
message_modulus: MessageModulus(message_modulus as u64),
carry_modulus: CarryModulus(carry_modulus as u64),
max_noise_level: MaxNoiseLevel::new(max_noise_level as u64),
log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(ciphertext_modulus).unwrap(),
encryption_key_choice: {
match &*encryption_key_choice {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
}
},
grouping_factor: LweBskGroupingFactor(grouping_factor),
deterministic_execution: false,
}
}
}
impl From<TestParameterSet> for PBSParameters {
fn from(value: TestParameterSet) -> Self {
let tmp: ClassicPBSParameters = value.into();
tmp.into()
match value {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
PBSParameters::PBS(test_classic_parameter_set.into())
}
TestParameterSet::TestMultiBitParameterSet(test_parameter_set_multi_bit) => {
PBSParameters::MultiBitPBS(test_parameter_set_multi_bit.into())
}
}
}
}

94
utils/tfhe-backward-compat-data/src/data_1_3.rs
View File

@@ -4,10 +4,10 @@ use crate::generate::{
};
use crate::{
DataKind, HlClientKeyTest, HlCompressedSquashedNoiseCiphertextListTest,
HlHeterogeneousCiphertextListTest, HlServerKeyTest, PkeZkProofAuxiliaryInfo, TestDistribution,
TestMetadata, TestModulusSwitchNoiseReductionParams, TestModulusSwitchType,
TestNoiseSquashingCompressionParameters, TestNoiseSquashingParams, TestParameterSet,
ZkPkePublicParamsTest, HL_MODULE_NAME,
HlHeterogeneousCiphertextListTest, HlServerKeyTest, PkeZkProofAuxiliaryInfo,
TestClassicParameterSet, TestDistribution, TestMetadata, TestModulusSwitchNoiseReductionParams,
TestModulusSwitchType, TestMultiBitParameterSet, TestNoiseSquashingCompressionParameters,
TestNoiseSquashingParams, TestParameterSet, ZkPkePublicParamsTest, HL_MODULE_NAME,
};
use std::borrow::Cow;
use std::fs::create_dir_all;
@@ -26,10 +26,10 @@ use tfhe_1_3::shortint::engine::ShortintEngine;
use tfhe_1_3::shortint::parameters::{
CarryModulus, CiphertextModulus, ClassicPBSParameters, CoreCiphertextModulus,
DecompositionBaseLog, DecompositionLevelCount, DynamicDistribution, EncryptionKeyChoice,
GlweDimension, LweCiphertextCount, LweDimension, MaxNoiseLevel, MessageModulus,
ModulusSwitchNoiseReductionParams, NoiseEstimationMeasureBound,
NoiseSquashingCompressionParameters, NoiseSquashingParameters, PolynomialSize, RSigmaFactor,
StandardDev, Variance,
GlweDimension, LweBskGroupingFactor, LweCiphertextCount, LweDimension, MaxNoiseLevel,
MessageModulus, ModulusSwitchNoiseReductionParams, MultiBitPBSParameters,
NoiseEstimationMeasureBound, NoiseSquashingCompressionParameters, NoiseSquashingParameters,
PolynomialSize, RSigmaFactor, StandardDev, Variance,
};
use tfhe_1_3::shortint::prelude::ModulusSwitchType;
use tfhe_1_3::shortint::AtomicPatternParameters;
@@ -111,8 +111,8 @@ impl From<TestModulusSwitchType> for ModulusSwitchType {
}
}
impl From<TestParameterSet> for ClassicPBSParameters {
fn from(value: TestParameterSet) -> Self {
impl From<TestClassicParameterSet> for ClassicPBSParameters {
fn from(value: TestClassicParameterSet) -> Self {
ClassicPBSParameters {
lwe_dimension: LweDimension(value.lwe_dimension),
glwe_dimension: GlweDimension(value.glwe_dimension),
@@ -142,11 +142,69 @@ impl From<TestParameterSet> for ClassicPBSParameters {
}
}
impl From<TestMultiBitParameterSet> for MultiBitPBSParameters {
fn from(value: TestMultiBitParameterSet) -> Self {
let TestMultiBitParameterSet {
lwe_dimension,
glwe_dimension,
polynomial_size,
lwe_noise_distribution,
glwe_noise_distribution,
pbs_base_log,
pbs_level,
ks_base_log,
ks_level,
message_modulus,
ciphertext_modulus,
carry_modulus,
max_noise_level,
log2_p_fail,
encryption_key_choice,
grouping_factor,
} = value;
MultiBitPBSParameters {
lwe_dimension: LweDimension(lwe_dimension),
glwe_dimension: GlweDimension(glwe_dimension),
polynomial_size: PolynomialSize(polynomial_size),
lwe_noise_distribution: lwe_noise_distribution.into(),
glwe_noise_distribution: glwe_noise_distribution.into(),
pbs_base_log: DecompositionBaseLog(pbs_base_log),
pbs_level: DecompositionLevelCount(pbs_level),
ks_base_log: DecompositionBaseLog(ks_base_log),
ks_level: DecompositionLevelCount(ks_level),
message_modulus: MessageModulus(message_modulus as u64),
carry_modulus: CarryModulus(carry_modulus as u64),
max_noise_level: MaxNoiseLevel::new(max_noise_level as u64),
log2_p_fail,
ciphertext_modulus: CiphertextModulus::try_new(ciphertext_modulus).unwrap(),
encryption_key_choice: {
match &*encryption_key_choice {
"big" => EncryptionKeyChoice::Big,
"small" => EncryptionKeyChoice::Small,
_ => panic!("Invalid encryption key choice"),
}
},
grouping_factor: LweBskGroupingFactor(grouping_factor),
deterministic_execution: false,
}
}
}
impl From<TestParameterSet> for AtomicPatternParameters {
fn from(value: TestParameterSet) -> Self {
let classic = ClassicPBSParameters::from(value);
match value {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
let classic = ClassicPBSParameters::from(test_classic_parameter_set);
classic.into()
classic.into()
}
TestParameterSet::TestMultiBitParameterSet(test_parameter_set_multi_bit) => {
let multibit = MultiBitPBSParameters::from(test_parameter_set_multi_bit);
multibit.into()
}
}
}
}
@@ -211,16 +269,16 @@ impl From<TestNoiseSquashingCompressionParameters> for NoiseSquashingCompression
const ZK_PKE_CRS_TEST: ZkPkePublicParamsTest = ZkPkePublicParamsTest {
test_filename: Cow::Borrowed("zk_pke_crs"),
lwe_dimension: VALID_TEST_PARAMS_TUNIFORM.polynomial_size
* VALID_TEST_PARAMS_TUNIFORM.glwe_dimension, // Lwe dimension of the "big" key is glwe dimension * polynomial size
lwe_dimension: VALID_TEST_PARAMS_TUNIFORM.polynomial_size()
* VALID_TEST_PARAMS_TUNIFORM.glwe_dimension(), // Lwe dimension of the "big" key is glwe dimension * polynomial size
max_num_cleartext: 16,
noise_bound: match VALID_TEST_PARAMS_TUNIFORM.lwe_noise_distribution {
noise_bound: match VALID_TEST_PARAMS_TUNIFORM.lwe_noise_distribution() {
TestDistribution::Gaussian { .. } => unreachable!(),
TestDistribution::TUniform { bound_log2 } => bound_log2 as usize,
},
ciphertext_modulus: VALID_TEST_PARAMS_TUNIFORM.ciphertext_modulus,
plaintext_modulus: VALID_TEST_PARAMS_TUNIFORM.message_modulus
* VALID_TEST_PARAMS_TUNIFORM.carry_modulus
ciphertext_modulus: VALID_TEST_PARAMS_TUNIFORM.ciphertext_modulus(),
plaintext_modulus: VALID_TEST_PARAMS_TUNIFORM.message_modulus()
* VALID_TEST_PARAMS_TUNIFORM.carry_modulus()
* 2, // *2 for padding bit
padding_bit_count: 1,
};

229
utils/tfhe-backward-compat-data/src/generate.rs
View File

@@ -11,126 +11,131 @@ use tfhe_1_3_versionable::Versionize as VersionizeTfhe_1_3;
use tfhe_versionable::{Versionize as VersionizeTfhe_0_10, Versionize as VersionizeTfhe_0_8};
use crate::{
data_dir, dir_for_version, TestCompressionParameterSet, TestDistribution, TestMetadata,
TestModulusSwitchNoiseReductionParams, TestModulusSwitchType,
data_dir, dir_for_version, TestClassicParameterSet, TestCompressionParameterSet,
TestDistribution, TestMetadata, TestModulusSwitchNoiseReductionParams, TestModulusSwitchType,
TestNoiseSquashingCompressionParameters, TestNoiseSquashingParams, TestParameterSet,
};
pub const PRNG_SEED: u128 = 0xdeadbeef;
/// Valid parameter set that can be used in tfhe operations
pub const VALID_TEST_PARAMS: TestParameterSet = TestParameterSet {
lwe_dimension: 761,
glwe_dimension: 1,
polynomial_size: 2048,
lwe_noise_distribution: TestDistribution::Gaussian {
stddev: 6.36835566258815e-06,
},
glwe_noise_distribution: TestDistribution::Gaussian {
stddev: 3.1529322391500584e-16,
},
pbs_base_log: 23,
pbs_level: 1,
ks_base_log: 3,
ks_level: 5,
message_modulus: 4,
carry_modulus: 4,
max_noise_level: 5,
log2_p_fail: -40.05,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("big"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::Standard,
};
pub const VALID_TEST_PARAMS_TUNIFORM: TestParameterSet = TestParameterSet {
lwe_dimension: 887,
glwe_dimension: 1,
polynomial_size: 2048,
lwe_noise_distribution: TestDistribution::TUniform { bound_log2: 46 },
glwe_noise_distribution: TestDistribution::TUniform { bound_log2: 17 },
pbs_base_log: 22,
pbs_level: 1,
ks_base_log: 3,
ks_level: 5,
message_modulus: 4,
carry_modulus: 4,
max_noise_level: 5,
log2_p_fail: -64.138,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("big"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::Standard,
};
/// Those parameters are insecure and are used to generate small legacy public keys
pub const INSECURE_SMALL_PK_TEST_PARAMS: TestParameterSet = TestParameterSet {
lwe_dimension: 10,
glwe_dimension: 4,
polynomial_size: 512,
lwe_noise_distribution: TestDistribution::Gaussian {
stddev: 1.499_900_593_439_687_3e-6,
},
glwe_noise_distribution: TestDistribution::Gaussian {
stddev: 2.845267479601915e-15,
},
pbs_base_log: 23,
pbs_level: 1,
ks_base_log: 5,
ks_level: 3,
message_modulus: 2,
carry_modulus: 2,
max_noise_level: 3,
log2_p_fail: -64.05,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("small"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::Standard,
};
/// Those parameters are insecure and are used to generate small legacy public keys
pub const INSECURE_SMALL_TEST_PARAMS_MS_NOISE_REDUCTION: TestParameterSet = TestParameterSet {
lwe_dimension: 2,
glwe_dimension: 1,
polynomial_size: 2048,
lwe_noise_distribution: TestDistribution::TUniform { bound_log2: 45 },
glwe_noise_distribution: TestDistribution::TUniform { bound_log2: 17 },
pbs_base_log: 23,
pbs_level: 1,
ks_base_log: 4,
ks_level: 4,
message_modulus: 4,
carry_modulus: 4,
max_noise_level: 5,
log2_p_fail: -129.15284804376165,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("big"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::DriftTechniqueNoiseReduction(
TestModulusSwitchNoiseReductionParams {
modulus_switch_zeros_count: 2,
ms_bound: 288230376151711744f64,
ms_r_sigma_factor: 13.179852282053789f64,
ms_input_variance: 2.63039184094559e-7f64,
pub const VALID_TEST_PARAMS: TestParameterSet =
TestParameterSet::TestClassicParameterSet(TestClassicParameterSet {
lwe_dimension: 761,
glwe_dimension: 1,
polynomial_size: 2048,
lwe_noise_distribution: TestDistribution::Gaussian {
stddev: 6.36835566258815e-06,
},
),
};
glwe_noise_distribution: TestDistribution::Gaussian {
stddev: 3.1529322391500584e-16,
},
pbs_base_log: 23,
pbs_level: 1,
ks_base_log: 3,
ks_level: 5,
message_modulus: 4,
carry_modulus: 4,
max_noise_level: 5,
log2_p_fail: -40.05,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("big"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::Standard,
});
pub const VALID_TEST_PARAMS_TUNIFORM: TestParameterSet =
TestParameterSet::TestClassicParameterSet(TestClassicParameterSet {
lwe_dimension: 887,
glwe_dimension: 1,
polynomial_size: 2048,
lwe_noise_distribution: TestDistribution::TUniform { bound_log2: 46 },
glwe_noise_distribution: TestDistribution::TUniform { bound_log2: 17 },
pbs_base_log: 22,
pbs_level: 1,
ks_base_log: 3,
ks_level: 5,
message_modulus: 4,
carry_modulus: 4,
max_noise_level: 5,
log2_p_fail: -64.138,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("big"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::Standard,
});
/// Those parameters are insecure and are used to generate small legacy public keys
pub const INSECURE_SMALL_TEST_PARAMS_MS_MEAN_COMPENSATION: TestParameterSet = TestParameterSet {
lwe_dimension: 2,
glwe_dimension: 1,
polynomial_size: 2048,
lwe_noise_distribution: TestDistribution::TUniform { bound_log2: 45 },
glwe_noise_distribution: TestDistribution::TUniform { bound_log2: 17 },
pbs_base_log: 23,
pbs_level: 1,
ks_base_log: 4,
ks_level: 4,
message_modulus: 4,
carry_modulus: 4,
max_noise_level: 5,
log2_p_fail: -129.15284804376165,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("big"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::CenteredMeanNoiseReduction,
};
pub const INSECURE_SMALL_PK_TEST_PARAMS: TestParameterSet =
TestParameterSet::TestClassicParameterSet(TestClassicParameterSet {
lwe_dimension: 10,
glwe_dimension: 4,
polynomial_size: 512,
lwe_noise_distribution: TestDistribution::Gaussian {
stddev: 1.499_900_593_439_687_3e-6,
},
glwe_noise_distribution: TestDistribution::Gaussian {
stddev: 2.845267479601915e-15,
},
pbs_base_log: 23,
pbs_level: 1,
ks_base_log: 5,
ks_level: 3,
message_modulus: 2,
carry_modulus: 2,
max_noise_level: 3,
log2_p_fail: -64.05,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("small"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::Standard,
});
/// Those parameters are insecure and are used to generate small legacy public keys
pub const INSECURE_SMALL_TEST_PARAMS_MS_NOISE_REDUCTION: TestParameterSet =
TestParameterSet::TestClassicParameterSet(TestClassicParameterSet {
lwe_dimension: 2,
glwe_dimension: 1,
polynomial_size: 2048,
lwe_noise_distribution: TestDistribution::TUniform { bound_log2: 45 },
glwe_noise_distribution: TestDistribution::TUniform { bound_log2: 17 },
pbs_base_log: 23,
pbs_level: 1,
ks_base_log: 4,
ks_level: 4,
message_modulus: 4,
carry_modulus: 4,
max_noise_level: 5,
log2_p_fail: -129.15284804376165,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("big"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::DriftTechniqueNoiseReduction(
TestModulusSwitchNoiseReductionParams {
modulus_switch_zeros_count: 2,
ms_bound: 288230376151711744f64,
ms_r_sigma_factor: 13.179852282053789f64,
ms_input_variance: 2.63039184094559e-7f64,
},
),
});
/// Those parameters are insecure and are used to generate small legacy public keys
pub const INSECURE_SMALL_TEST_PARAMS_MS_MEAN_COMPENSATION: TestParameterSet =
TestParameterSet::TestClassicParameterSet(TestClassicParameterSet {
lwe_dimension: 2,
glwe_dimension: 1,
polynomial_size: 2048,
lwe_noise_distribution: TestDistribution::TUniform { bound_log2: 45 },
glwe_noise_distribution: TestDistribution::TUniform { bound_log2: 17 },
pbs_base_log: 23,
pbs_level: 1,
ks_base_log: 4,
ks_level: 4,
message_modulus: 4,
carry_modulus: 4,
max_noise_level: 5,
log2_p_fail: -129.15284804376165,
ciphertext_modulus: 1 << 64,
encryption_key_choice: Cow::Borrowed("big"),
modulus_switch_noise_reduction_params: TestModulusSwitchType::CenteredMeanNoiseReduction,
});
/// Those parameters are insecure and are used to generate small legacy public keys
/// Got with the above parameters for noise squashing
@@ -181,7 +186,7 @@ pub const VALID_TEST_PARAMS_TUNIFORM_COMPRESSION: TestCompressionParameterSet =
};
/// Invalid parameter set to test the limits
pub const INVALID_TEST_PARAMS: TestParameterSet = TestParameterSet {
pub const INVALID_TEST_PARAMS: TestClassicParameterSet = TestClassicParameterSet {
lwe_dimension: usize::MAX,
glwe_dimension: usize::MAX,
polynomial_size: usize::MAX,

115
utils/tfhe-backward-compat-data/src/lib.rs
View File

@@ -39,7 +39,7 @@ pub const ZK_MODULE_NAME: &str = "zk";
/// The idea here is to define a type that is able to carry the information of the used parameters
/// without using any tfhe-rs types.
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct TestParameterSet {
pub struct TestClassicParameterSet {
pub lwe_dimension: usize,
pub glwe_dimension: usize,
pub polynomial_size: usize,
@@ -58,6 +58,26 @@ pub struct TestParameterSet {
pub modulus_switch_noise_reduction_params: TestModulusSwitchType,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct TestMultiBitParameterSet {
pub lwe_dimension: usize,
pub glwe_dimension: usize,
pub polynomial_size: usize,
pub lwe_noise_distribution: TestDistribution,
pub glwe_noise_distribution: TestDistribution,
pub pbs_base_log: usize,
pub pbs_level: usize,
pub ks_base_log: usize,
pub ks_level: usize,
pub message_modulus: usize,
pub ciphertext_modulus: u128,
pub carry_modulus: usize,
pub max_noise_level: usize,
pub log2_p_fail: f64,
pub encryption_key_choice: Cow<'static, str>,
pub grouping_factor: usize,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct TestModulusSwitchNoiseReductionParams {
pub modulus_switch_zeros_count: usize,
@@ -86,6 +106,19 @@ pub struct TestNoiseSquashingParams {
pub ciphertext_modulus: u128,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct TestNoiseSquashingParamsMultiBit {
pub glwe_dimension: usize,
pub polynomial_size: usize,
pub glwe_noise_distribution: TestDistribution,
pub decomp_base_log: usize,
pub decomp_level_count: usize,
pub grouping_factor: usize,
pub message_modulus: usize,
pub carry_modulus: usize,
pub ciphertext_modulus: u128,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct TestNoiseSquashingCompressionParameters {
pub packing_ks_level: usize,
@@ -118,7 +151,7 @@ pub struct TestCompressionParameterSet {
}
/// Representation of a random distribution that is independent from any tfhe-rs version
#[derive(Serialize, Deserialize, Clone, Debug)]
#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
pub enum TestDistribution {
Gaussian { stddev: f64 },
TUniform { bound_log2: u32 },
@@ -218,6 +251,84 @@ pub struct HlClientKeyTest {
pub parameters: TestParameterSet,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum TestParameterSet {
TestClassicParameterSet(TestClassicParameterSet),
TestMultiBitParameterSet(TestMultiBitParameterSet),
}
#[allow(dead_code)]
impl TestParameterSet {
pub const fn from_classic(value: TestClassicParameterSet) -> Self {
Self::TestClassicParameterSet(value)
}
pub const fn from_multi(value: TestMultiBitParameterSet) -> Self {
Self::TestMultiBitParameterSet(value)
}
const fn polynomial_size(&self) -> usize {
match self {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
test_classic_parameter_set.polynomial_size
}
TestParameterSet::TestMultiBitParameterSet(test_multi_bit_parameter_set) => {
test_multi_bit_parameter_set.polynomial_size
}
}
}
const fn glwe_dimension(&self) -> usize {
match self {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
test_classic_parameter_set.glwe_dimension
}
TestParameterSet::TestMultiBitParameterSet(test_multi_bit_parameter_set) => {
test_multi_bit_parameter_set.glwe_dimension
}
}
}
const fn lwe_noise_distribution(&self) -> TestDistribution {
match self {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
test_classic_parameter_set.lwe_noise_distribution
}
TestParameterSet::TestMultiBitParameterSet(test_multi_bit_parameter_set) => {
test_multi_bit_parameter_set.lwe_noise_distribution
}
}
}
const fn ciphertext_modulus(&self) -> u128 {
match self {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
test_classic_parameter_set.ciphertext_modulus
}
TestParameterSet::TestMultiBitParameterSet(test_multi_bit_parameter_set) => {
test_multi_bit_parameter_set.ciphertext_modulus
}
}
}
const fn message_modulus(&self) -> usize {
match self {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
test_classic_parameter_set.message_modulus
}
TestParameterSet::TestMultiBitParameterSet(test_multi_bit_parameter_set) => {
test_multi_bit_parameter_set.message_modulus
}
}
}
const fn carry_modulus(&self) -> usize {
match self {
TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
test_classic_parameter_set.carry_modulus
}
TestParameterSet::TestMultiBitParameterSet(test_multi_bit_parameter_set) => {
test_multi_bit_parameter_set.carry_modulus
}
}
}
}
impl TestType for HlClientKeyTest {
fn module(&self) -> String {
HL_MODULE_NAME.to_string()