chore: backward data test for CompressedSquashedNoiseCiphertextList

Author: tmontaigu

tests/Cargo.toml

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

tests/backward_compatibility/high_level_api.rs

@@ -1,24 +1,25 @@
 use super::shortint::load_params;
 use crate::{load_and_unversionize, TestedModule};
 use std::path::Path;
+#[cfg(feature = "zk-pok")]
 use tfhe::integer::parameters::DynamicDistribution;
 use tfhe::prelude::{CiphertextList, FheDecrypt, FheEncrypt, ParameterSetConformant};
+#[cfg(feature = "zk-pok")]
 use tfhe::shortint::parameters::{
     CompactCiphertextListExpansionKind, CompactPublicKeyEncryptionParameters,
 };
+#[cfg(feature = "zk-pok")]
 use tfhe::shortint::prelude::LweDimension;
 use tfhe::shortint::{
     AtomicPatternParameters, CarryModulus, CiphertextModulus, MessageModulus, PBSParameters,
 };
 #[cfg(feature = "zk-pok")]
-use tfhe::zk::CompactPkeCrs;
-#[cfg(feature = "zk-pok")]
-use tfhe::zk::CompactPkeCrsConformanceParams;
+use tfhe::zk::{CompactPkeCrs, CompactPkeCrsConformanceParams};
 use tfhe::{
     set_server_key, ClientKey, CompactCiphertextList, CompressedCiphertextList,
     CompressedCompactPublicKey, CompressedFheBool, CompressedFheInt8, CompressedFheUint8,
-    CompressedPublicKey, CompressedServerKey, FheBool, FheInt8, FheUint8, SquashedNoiseFheBool,
-    SquashedNoiseFheInt, SquashedNoiseFheUint,
+    CompressedPublicKey, CompressedServerKey, CompressedSquashedNoiseCiphertextList, FheBool,
+    FheInt8, FheUint8, SquashedNoiseFheBool, SquashedNoiseFheInt, SquashedNoiseFheUint,
 };
 #[cfg(feature = "zk-pok")]
 use tfhe::{CompactPublicKey, ProvenCompactCiphertextList};
@@ -27,10 +28,10 @@ use tfhe_backward_compat_data::load::{
 };
 use tfhe_backward_compat_data::{
     DataKind, HlBoolCiphertextTest, HlCiphertextTest, HlClientKeyTest,
-    HlHeterogeneousCiphertextListTest, HlPublicKeyTest, HlServerKeyTest, HlSignedCiphertextTest,
-    HlSquashedNoiseBoolCiphertextTest, HlSquashedNoiseSignedCiphertextTest,
-    HlSquashedNoiseUnsignedCiphertextTest, TestMetadata, TestParameterSet, TestType, Testcase,
-    ZkPkePublicParamsTest,
+    HlCompressedSquashedNoiseCiphertextListTest, HlHeterogeneousCiphertextListTest,
+    HlPublicKeyTest, HlServerKeyTest, HlSignedCiphertextTest, HlSquashedNoiseBoolCiphertextTest,
+    HlSquashedNoiseSignedCiphertextTest, HlSquashedNoiseUnsignedCiphertextTest, TestMetadata,
+    TestParameterSet, TestType, Testcase, ZkPkePublicParamsTest,
 };
 use tfhe_versionable::Unversionize;
 
@@ -495,6 +496,67 @@ pub fn test_hl_squashed_noise_bool_ciphertext(
     }
 }
 
+/// Test HL compressed squashed noise ciphertext list:
+/// loads the ciphertext list and compare the decrypted value to the one in the
+/// metadata.
+pub fn test_hl_compressed_squashed_noise_ciphertext_list(
+    dir: &Path,
+    test: &HlCompressedSquashedNoiseCiphertextListTest,
+    format: DataFormat,
+) -> Result<TestSuccess, TestFailure> {
+    let key_file = dir.join(&*test.key_filename);
+    let key = ClientKey::unversionize(
+        load_versioned_auxiliary(key_file).map_err(|e| test.failure(e, format))?,
+    )
+    .map_err(|e| test.failure(format!("Failed to load key file: {e}"), format))?;
+
+    let list: CompressedSquashedNoiseCiphertextList = load_and_unversionize(dir, test, format)
+        .map_err(|e| test.failure(format!("Failed to load list file: {e}"), format))?;
+
+    if list.len() != test.clear_values.len() || list.len() != test.data_kinds.len() {
+        return Err(test.failure(
+            format!(
+                "Invalid len for the compressed list, expected {} elements, got {}",
+                test.clear_values.len(),
+                list.len()
+            ),
+            format,
+        ));
+    }
+
+    for i in 0..list.len() {
+        let decrypted = match test.data_kinds[i] {
+            DataKind::Unsigned => {
+                let ct: SquashedNoiseFheUint = list.get(i).unwrap().unwrap();
+                let clear: u64 = ct.decrypt(&key);
+                clear
+            }
+            DataKind::Signed => {
+                let ct: SquashedNoiseFheInt = list.get(i).unwrap().unwrap();
+                let clear: i64 = ct.decrypt(&key);
+                clear as u64
+            }
+            DataKind::Bool => {
+                let ct: SquashedNoiseFheBool = list.get(i).unwrap().unwrap();
+                let clear: bool = ct.decrypt(&key);
+                clear as u64
+            }
+        };
+
+        let expected = test.clear_values[i];
+        if decrypted != expected {
+            return Err(test.failure(
+                format!(
+                    "Invalid decryption at index {i}:\n Expected :{expected:?} Got: {decrypted:?}",
+                ),
+                format,
+            ));
+        }
+    }
+
+    Ok(test.success(format))
+}
+
 pub struct Hl;
 
 impl TestedModule for Hl {
@@ -540,6 +602,10 @@ impl TestedModule for Hl {
             TestMetadata::HlSquashedNoiseBoolCiphertext(test) => {
                 test_hl_squashed_noise_bool_ciphertext(test_dir.as_ref(), test, format).into()
             }
+            TestMetadata::HlCompressedSquashedNoiseCiphertextList(test) => {
+                test_hl_compressed_squashed_noise_ciphertext_list(test_dir.as_ref(), test, format)
+                    .into()
+            }
             _ => {
                 println!("WARNING: missing test: {:?}", testcase.metadata);
                 TestResult::Skipped(testcase.skip())

tfhe/src/high_level_api/compressed_noise_squashed_ciphertext_list.rs

@@ -118,6 +118,19 @@ impl InnerCompressedSquashedNoiseCiphertextList {
     }
 }
 
+/// Compressed ciphertext list for squashed noise ciphertext
+///
+/// This list supports
+///
+/// * [SquashedNoiseFheUint]
+/// * [SquashedNoiseFheInt]
+/// * [SquashedNoiseFheBool]
+///
+/// Use the [CompressedSquashedNoiseCiphertextListBuilder] struct to
+/// build a list.
+///
+/// This requires the server key to have noise-squashing compression keys,
+/// which is enabled by calling [crate::ConfigBuilder::enable_noise_squashing_compression]
 #[derive(Serialize, Deserialize, Versionize)]
 #[versionize(CompressedSquashedNoiseCiphertextListVersions)]
 pub struct CompressedSquashedNoiseCiphertextList {
@@ -290,6 +303,10 @@ impl HlSquashedNoiseCompressible for SquashedNoiseFheInt {
     }
 }
 
+/// Builder to create [CompressedSquashedNoiseCiphertextList]
+///
+/// Use [push](Self::push) to add squashed noise ciphertext to the list,
+/// then call [build](Self::build) to build the list.
 pub struct CompressedSquashedNoiseCiphertextListBuilder {
     inner: Vec<(private::SquashedNoiseToBeCompressed, DataKind)>,
 }

tfhe/src/high_level_api/config.rs

@@ -67,6 +67,11 @@ impl ConfigBuilder {
         self
     }
 
+    /// Enable the generation of keys needed for [crate::CompressedSquashedNoiseCiphertextList]
+    ///
+    /// # Note
+    ///
+    /// This requires nose squashing to be enabled first via [Self::enable_noise_squashing]
     pub fn enable_noise_squashing_compression(
         mut self,
         compression_parameters: NoiseSquashingCompressionParameters,

tfhe/src/high_level_api/keys/inner.rs

@@ -728,7 +728,7 @@ impl ParameterSetConformant for IntegerServerKey {
             parameter_set.noise_squashing_compression_param.as_ref(),
             noise_squashing_compression_key.as_ref(),
         ) {
-            (None, None, None) | (Some(_), None, None) => true,
+            (None | Some(_), None, None) => true,
             (
                 Some(noise_squashing_parameters),
                 Some(noise_squashing_compression_param),
@@ -818,7 +818,7 @@ impl ParameterSetConformant for IntegerCompressedServerKey {
             parameter_set.noise_squashing_compression_param.as_ref(),
             noise_squashing_compression_key.as_ref(),
         ) {
-            (None, None, None) | (Some(_), None, None) => true,
+            (None | Some(_), None, None) => true,
             (
                 Some(noise_squashing_parameters),
                 Some(noise_squashing_compression_param),