Mz/reduce ms noise

tests/Cargo.toml

@@ -7,7 +7,7 @@ publish = false
 [dev-dependencies]
 tfhe = { path = "../tfhe" }
 tfhe-versionable = { path = "../utils/tfhe-versionable" }
-tfhe-backward-compat-data = { git = "https://github.com/zama-ai/tfhe-backward-compat-data.git", branch = "v0.5", default-features = false, features = [
+tfhe-backward-compat-data = { git = "https://github.com/zama-ai/tfhe-backward-compat-data.git", branch = "v0.6", default-features = false, features = [
     "load",
 ] }
 ron = "0.8"

tests/backward_compatibility/shortint.rs

@@ -1,12 +1,14 @@
 use std::path::Path;
-
-use tfhe::core_crypto::prelude::TUniform;
+use tfhe::core_crypto::prelude::{
+    LweCiphertextCount, NoiseEstimationMeasureBound, RSigmaFactor, TUniform,
+};
+use tfhe::shortint::parameters::ModulusSwitchNoiseReductionParams;
 use tfhe_backward_compat_data::load::{
     load_versioned_auxiliary, DataFormat, TestFailure, TestResult, TestSuccess,
 };
 use tfhe_backward_compat_data::{
     ShortintCiphertextTest, ShortintClientKeyTest, TestDistribution, TestMetadata,
-    TestParameterSet, TestType, Testcase,
+    TestModulusSwitchNoiseReductionParams, TestParameterSet, TestType, Testcase,
 };
 
 use tfhe::shortint::parameters::{
@@ -24,28 +26,62 @@ 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;
+
+    let modulus_switch_noise_reduction_params = modulus_switch_noise_reduction_params.as_ref().map(
+        |TestModulusSwitchNoiseReductionParams {
+             modulus_switch_zeros_count,
+             ms_bound,
+             ms_r_sigma_factor,
+         }| {
+            ModulusSwitchNoiseReductionParams {
+                modulus_switch_zeros_count: LweCiphertextCount(*modulus_switch_zeros_count),
+                ms_bound: NoiseEstimationMeasureBound(*ms_bound),
+                ms_r_sigma_factor: RSigmaFactor(*ms_r_sigma_factor),
+            }
+        },
+    );
+
     ClassicPBSParameters {
-        lwe_dimension: LweDimension(test_params.lwe_dimension),
-        glwe_dimension: GlweDimension(test_params.glwe_dimension),
-        polynomial_size: PolynomialSize(test_params.polynomial_size),
-        lwe_noise_distribution: convert_distribution(&test_params.lwe_noise_distribution),
-        glwe_noise_distribution: convert_distribution(&test_params.glwe_noise_distribution),
-        pbs_base_log: DecompositionBaseLog(test_params.pbs_base_log),
-        pbs_level: DecompositionLevelCount(test_params.pbs_level),
-        ks_base_log: DecompositionBaseLog(test_params.ks_base_log),
-        ks_level: DecompositionLevelCount(test_params.ks_level),
-        message_modulus: MessageModulus(test_params.message_modulus as u64),
-        carry_modulus: CarryModulus(test_params.carry_modulus as u64),
-        max_noise_level: MaxNoiseLevel::new(test_params.max_noise_level as u64),
-        log2_p_fail: test_params.log2_p_fail,
-        ciphertext_modulus: CiphertextModulus::try_new(test_params.ciphertext_modulus).unwrap(),
+        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 &*test_params.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,
     }
 }
 

tfhe/Cargo.toml

@@ -165,6 +165,13 @@ path = "benches/core_crypto/dev_bench.rs"
 harness = false
 required-features = ["internal-keycache"]
 
+[[bench]]
+name = "modulus_switch_noise_reduction"
+path = "benches/core_crypto/modulus_switch_noise_reduction.rs"
+harness = false
+required-features = ["shortint"]
+
+
 [[bench]]
 name = "pbs128-bench"
 path = "benches/core_crypto/pbs128_bench.rs"

tfhe/benches/core_crypto/modulus_switch_noise_reduction.rs

@@ -0,0 +1,87 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use modulus_switch_noise_reduction::improve_lwe_ciphertext_modulus_switch_noise_for_binary_key;
+use tfhe::core_crypto::commons::parameters::{NoiseEstimationMeasureBound, RSigmaFactor};
+use tfhe::core_crypto::prelude::*;
+
+fn modulus_switch_noise_reduction(c: &mut Criterion) {
+    // TODO: use shortint params
+    let lwe_dimension = LweDimension(918);
+    let noise_distribution = DynamicDistribution::new_t_uniform(46);
+    let ciphertext_modulus = CiphertextModulus::new_native();
+    let bound = NoiseEstimationMeasureBound((1_u64 << (64 - 1 - 4 - 1)) as f64);
+    let r_sigma_factor = RSigmaFactor(14.658999256586121);
+    let log_modulus = PolynomialSize(2048).to_blind_rotation_input_modulus_log();
+
+    for count in [10, 50, 100, 1_000, 10_000, 100_000] {
+        let mut boxed_seeder = new_seeder();
+        let seeder = boxed_seeder.as_mut();
+
+        let mut secret_generator =
+            SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
+
+        let mut encryption_generator =
+            EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
+
+        let sk =
+            allocate_and_generate_new_binary_lwe_secret_key(lwe_dimension, &mut secret_generator);
+
+        let clean_lwe = allocate_and_encrypt_new_lwe_ciphertext(
+            &sk,
+            Plaintext(0),
+            noise_distribution,
+            ciphertext_modulus,
+            &mut encryption_generator,
+        );
+
+        let mut encryptions_of_zero = LweCiphertextList::new(
+            0,
+            lwe_dimension.to_lwe_size(),
+            LweCiphertextCount(count),
+            ciphertext_modulus,
+        );
+
+        let plaintext_list = PlaintextList::new(0, PlaintextCount(count));
+
+        encrypt_lwe_ciphertext_list(
+            &sk,
+            &mut encryptions_of_zero,
+            &plaintext_list,
+            noise_distribution,
+            &mut encryption_generator,
+        );
+
+        let mut lwe =
+            LweCiphertext::new(0_u64, sk.lwe_dimension().to_lwe_size(), ciphertext_modulus);
+
+        let bench_name = "modulus_switch_noise_reduction";
+
+        let mut bench_group = c.benchmark_group(bench_name);
+        bench_group
+            .sample_size(15)
+            .measurement_time(std::time::Duration::from_secs(5));
+
+        let bench_name = format!("modulus_switch_noise_reduction_{count}");
+
+        bench_group.bench_function(&bench_name, |b| {
+            b.iter(|| {
+                lwe.as_mut().copy_from_slice(clean_lwe.as_ref());
+
+                improve_lwe_ciphertext_modulus_switch_noise_for_binary_key(
+                    &mut lwe,
+                    &encryptions_of_zero,
+                    r_sigma_factor,
+                    bound,
+                    log_modulus,
+                );
+
+                black_box(&lwe);
+            });
+        });
+    }
+}
+
+criterion_group!(
+    modulus_switch_noise_reduction2,
+    modulus_switch_noise_reduction
+);
+criterion_main!(modulus_switch_noise_reduction2);

tfhe/docs/references/fine-grained-apis/shortint/parameters.md

@@ -73,6 +73,7 @@ fn main() {
         log2_p_fail: -71.625,
         ciphertext_modulus: CiphertextModulus::new_native(),
         encryption_key_choice: EncryptionKeyChoice::Big,
+        modulus_switch_noise_reduction_params: None,
     };
 }
 ```