chore: use dedicated types for compressed modswitched conformance

Author: nsarlin-zama

tfhe/src/c_api/high_level_api/booleans.rs

@@ -46,7 +46,7 @@ impl_destroy_on_type!(CompressedFheBool);
 impl_clone_on_type!(CompressedFheBool);
 impl_serialize_deserialize_on_type!(CompressedFheBool);
 impl_safe_serialize_on_type!(CompressedFheBool);
-impl_safe_deserialize_conformant_on_type!(CompressedFheBool, FheBoolConformanceParams);
+impl_safe_deserialize_conformant_on_type!(CompressedFheBool, CompressedFheBoolConformanceParams);
 impl_try_encrypt_with_client_key_on_type!(CompressedFheBool{crate::high_level_api::CompressedFheBool}, bool);
 
 #[no_mangle]

tfhe/src/c_api/high_level_api/integers.rs

@@ -359,7 +359,7 @@ macro_rules! create_integer_wrapper_type {
 
             impl_safe_serialize_on_type!([<Compressed $name>]);
 
-            impl_safe_deserialize_conformant_on_type!([<Compressed $name>],  [<$name ConformanceParams>]);
+            impl_safe_deserialize_conformant_on_type!([<Compressed $name>],  [<Compressed $name ConformanceParams>]);
 
             #[no_mangle]
             pub unsafe extern "C" fn [<compressed_ $name:snake _decompress>](

tfhe/src/core_crypto/entities/compressed_modulus_switched_lwe_ciphertext.rs

@@ -135,30 +135,55 @@ impl<PackingScalar: UnsignedInteger> CompressedModulusSwitchedLweCiphertext<Pack
     }
 }
 
+#[derive(Copy, Clone)]
+pub enum MsDecompressionType {
+    ClassicPbs,
+    MultiBitPbs(LweBskGroupingFactor),
+}
+
+#[derive(Copy, Clone)]
+pub struct CompressedModulusSwitchedLweCiphertextConformanceParams<Scalar>
+where
+    Scalar: UnsignedInteger,
+{
+    pub ct_params: LweCiphertextConformanceParams<Scalar>,
+    pub ms_decompression_type: MsDecompressionType,
+}
+
 impl<Scalar: UnsignedInteger> ParameterSetConformant
     for CompressedModulusSwitchedLweCiphertext<Scalar>
 {
-    type ParameterSet = LweCiphertextConformanceParams<Scalar>;
+    type ParameterSet = CompressedModulusSwitchedLweCiphertextConformanceParams<Scalar>;
 
-    fn is_conformant(&self, lwe_ct_parameters: &LweCiphertextConformanceParams<Scalar>) -> bool {
+    fn is_conformant(
+        &self,
+        compressed_ct_parameters: &CompressedModulusSwitchedLweCiphertextConformanceParams<Scalar>,
+    ) -> bool {
         let Self {
             packed_integers,
             lwe_dimension,
         } = self;
 
+        let CompressedModulusSwitchedLweCiphertextConformanceParams {
+            ct_params,
+            ms_decompression_type,
+        } = compressed_ct_parameters;
+
+        let LweCiphertextConformanceParams {
+            lwe_dim: params_lwe_dim,
+            ct_modulus,
+        } = ct_params;
+
         let lwe_size = lwe_dimension.to_lwe_size().0;
 
         let number_bits_to_pack = lwe_size * packed_integers.log_modulus().0;
 
         let len = number_bits_to_pack.div_ceil(Scalar::BITS);
 
         packed_integers.packed_coeffs().len() == len
-            && *lwe_dimension == lwe_ct_parameters.lwe_dim
-            && lwe_ct_parameters.ct_modulus.is_power_of_two()
-            && matches!(
-                lwe_ct_parameters.ms_decompression_method,
-                MsDecompressionType::ClassicPbs
-            )
+            && lwe_dimension == params_lwe_dim
+            && ct_modulus.is_power_of_two()
+            && matches!(ms_decompression_type, MsDecompressionType::ClassicPbs)
     }
 }
 

tfhe/src/core_crypto/entities/compressed_modulus_switched_multi_bit_lwe_ciphertext.rs

@@ -511,9 +511,12 @@ impl MultiBitModulusSwitchedLweCiphertext for FromCompressionMultiBitModulusSwit
 impl<Scalar: UnsignedInteger + CastInto<usize> + CastFrom<usize>> ParameterSetConformant
     for CompressedModulusSwitchedMultiBitLweCiphertext<Scalar>
 {
-    type ParameterSet = LweCiphertextConformanceParams<Scalar>;
+    type ParameterSet = CompressedModulusSwitchedLweCiphertextConformanceParams<Scalar>;
 
-    fn is_conformant(&self, lwe_ct_parameters: &LweCiphertextConformanceParams<Scalar>) -> bool {
+    fn is_conformant(
+        &self,
+        compressed_ct_parameters: &CompressedModulusSwitchedLweCiphertextConformanceParams<Scalar>,
+    ) -> bool {
         let Self {
             body,
             packed_mask,
@@ -523,22 +526,30 @@ impl<Scalar: UnsignedInteger + CastInto<usize> + CastFrom<usize>> ParameterSetCo
             grouping_factor,
         } = self;
 
-        let lwe_dim = lwe_dimension.0;
+        let CompressedModulusSwitchedLweCiphertextConformanceParams {
+            ct_params,
+            ms_decompression_type,
+        } = compressed_ct_parameters;
+
+        let LweCiphertextConformanceParams {
+            lwe_dim: params_lwe_dim,
+            ct_modulus,
+        } = ct_params;
 
         *body >> packed_mask.log_modulus().0 == Scalar::ZERO
-            && packed_mask.is_conformant(&lwe_dim)
+            && packed_mask.is_conformant(&lwe_dimension.0)
             && packed_diffs
                 .as_ref()
-                .is_none_or(|packed_diffs| packed_diffs.is_conformant(&lwe_dim))
-            && *lwe_dimension == lwe_ct_parameters.lwe_dim
-            && lwe_ct_parameters.ct_modulus.is_power_of_two()
-            && match lwe_ct_parameters.ms_decompression_method {
+                .is_none_or(|packed_diffs| packed_diffs.is_conformant(&lwe_dimension.0))
+            && lwe_dimension == params_lwe_dim
+            && ct_modulus.is_power_of_two()
+            && match ms_decompression_type {
                 MsDecompressionType::ClassicPbs => false,
                 MsDecompressionType::MultiBitPbs(expected_grouping_factor) => {
                     expected_grouping_factor.0 == grouping_factor.0
                 }
             }
-            && *uncompressed_ciphertext_modulus == lwe_ct_parameters.ct_modulus
+            && uncompressed_ciphertext_modulus == ct_modulus
     }
 }
 

tfhe/src/core_crypto/entities/lwe_ciphertext.rs

@@ -753,13 +753,6 @@ pub type LweCiphertextMutView<'data, Scalar> = LweCiphertext<&'data mut [Scalar]
 pub struct LweCiphertextConformanceParams<T: UnsignedInteger> {
     pub lwe_dim: LweDimension,
     pub ct_modulus: CiphertextModulus<T>,
-    pub ms_decompression_method: MsDecompressionType,
-}
-
-#[derive(Copy, Clone)]
-pub enum MsDecompressionType {
-    ClassicPbs,
-    MultiBitPbs(LweBskGroupingFactor),
 }
 
 impl<C: Container> ParameterSetConformant for LweCiphertext<C>
@@ -777,9 +770,14 @@ where
             ciphertext_modulus,
         } = self;
 
-        check_encrypted_content_respects_mod(data, lwe_ct_parameters.ct_modulus)
-            && self.lwe_size() == lwe_ct_parameters.lwe_dim.to_lwe_size()
-            && *ciphertext_modulus == lwe_ct_parameters.ct_modulus
+        let LweCiphertextConformanceParams {
+            lwe_dim,
+            ct_modulus,
+        } = lwe_ct_parameters;
+
+        check_encrypted_content_respects_mod(data, *ct_modulus)
+            && self.lwe_size() == lwe_dim.to_lwe_size()
+            && ciphertext_modulus == ct_modulus
     }
 }
 

tfhe/src/high_level_api/booleans/compressed.rs

@@ -9,9 +9,12 @@ use crate::high_level_api::traits::Tagged;
 use crate::integer::BooleanBlock;
 use crate::named::Named;
 use crate::prelude::FheTryEncrypt;
-use crate::shortint::ciphertext::{CompressedModulusSwitchedCiphertext, Degree};
-use crate::shortint::CompressedCiphertext;
-use crate::{ClientKey, FheBool, FheBoolConformanceParams, Tag};
+use crate::shortint::ciphertext::{
+    CompressedModulusSwitchedCiphertext, CompressedModulusSwitchedCiphertextConformanceParams,
+    Degree,
+};
+use crate::shortint::{AtomicPatternParameters, CompressedCiphertext};
+use crate::{ClientKey, FheBool, ServerKey, Tag};
 use serde::{Deserialize, Serialize};
 use tfhe_versionable::Versionize;
 
@@ -111,12 +114,35 @@ impl FheTryEncrypt<bool, ClientKey> for CompressedFheBool {
     }
 }
 
+#[derive(Copy, Clone)]
+pub struct CompressedFheBoolConformanceParams(
+    pub(crate) CompressedModulusSwitchedCiphertextConformanceParams,
+);
+
+impl<P: Into<AtomicPatternParameters>> From<P> for CompressedFheBoolConformanceParams {
+    fn from(params: P) -> Self {
+        let params = params.into();
+        Self(params.to_compressed_modswitched_conformance_param())
+    }
+}
+
+impl From<&ServerKey> for CompressedFheBoolConformanceParams {
+    fn from(sk: &ServerKey) -> Self {
+        Self(
+            sk.key
+                .pbs_key()
+                .key
+                .compressed_modswitched_conformance_params(),
+        )
+    }
+}
+
 impl ParameterSetConformant for CompressedFheBool {
-    type ParameterSet = FheBoolConformanceParams;
+    type ParameterSet = CompressedFheBoolConformanceParams;
 
-    fn is_conformant(&self, params: &FheBoolConformanceParams) -> bool {
+    fn is_conformant(&self, params: &CompressedFheBoolConformanceParams) -> bool {
         match &self.inner {
-            InnerCompressedFheBool::Seeded(seeded) => seeded.is_conformant(&params.0),
+            InnerCompressedFheBool::Seeded(seeded) => seeded.is_conformant(&params.0.into()),
             InnerCompressedFheBool::ModulusSwitched(ct) => ct.is_conformant(&params.0),
         }
     }

tfhe/src/high_level_api/booleans/mod.rs

@@ -1,5 +1,5 @@
 pub use base::{FheBool, FheBoolConformanceParams};
-pub use compressed::CompressedFheBool;
+pub use compressed::{CompressedFheBool, CompressedFheBoolConformanceParams};
 pub use squashed_noise::SquashedNoiseFheBool;
 
 pub(in crate::high_level_api) use compressed::InnerCompressedFheBool;

tfhe/src/high_level_api/booleans/tests.rs

@@ -318,6 +318,7 @@ fn compressed_bool_test_case(setup_fn: impl FnOnce() -> (ClientKey, Device)) {
 
 mod cpu {
     use super::*;
+    use crate::high_level_api::booleans::compressed::CompressedFheBoolConformanceParams;
     use crate::safe_serialization::{DeserializationConfig, SerializationConfig};
     use crate::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS;
     use crate::FheBoolConformanceParams;
@@ -707,12 +708,14 @@ mod cpu {
             .serialize_into(&a, &mut serialized)
             .unwrap();
 
-        let params = FheBoolConformanceParams::from(&server_key);
+        let params = CompressedFheBoolConformanceParams::from(&server_key);
         let deserialized_a = DeserializationConfig::new(1 << 20)
             .deserialize_from::<CompressedFheBool>(serialized.as_slice(), &params)
             .unwrap();
 
-        assert!(deserialized_a.is_conformant(&FheBoolConformanceParams::from(block_params)));
+        assert!(
+            deserialized_a.is_conformant(&CompressedFheBoolConformanceParams::from(block_params))
+        );
 
         let decrypted: bool = deserialized_a.decompress().decrypt(&keys);
         assert_eq!(decrypted, clear_a);

tfhe/src/high_level_api/integers/signed/compressed.rs

@@ -1,3 +1,5 @@
+use std::marker::PhantomData;
+
 use tfhe_versionable::Versionize;
 
 use crate::backward_compatibility::integers::{
@@ -6,20 +8,20 @@ use crate::backward_compatibility::integers::{
 use crate::conformance::ParameterSetConformant;
 use crate::core_crypto::prelude::SignedNumeric;
 use crate::high_level_api::global_state;
-use crate::high_level_api::integers::signed::base::FheIntConformanceParams;
 use crate::high_level_api::integers::{FheInt, FheIntId};
 use crate::high_level_api::keys::InternalServerKey;
 use crate::high_level_api::re_randomization::ReRandomizationMetadata;
 use crate::high_level_api::traits::Tagged;
 use crate::integer::block_decomposition::DecomposableInto;
 use crate::integer::ciphertext::{
+    CompressedModulusSwitchedRadixCiphertextConformanceParams,
     CompressedModulusSwitchedSignedRadixCiphertext,
     CompressedSignedRadixCiphertext as IntegerCompressedSignedRadixCiphertext,
 };
-use crate::integer::parameters::RadixCiphertextConformanceParams;
 use crate::named::Named;
 use crate::prelude::FheTryEncrypt;
-use crate::{ClientKey, Tag};
+use crate::shortint::AtomicPatternParameters;
+use crate::{ClientKey, ServerKey, Tag};
 
 /// Compressed [FheInt]
 ///
@@ -153,10 +155,51 @@ where
     }
 }
 
+#[derive(Copy, Clone)]
+pub struct CompressedFheIntConformanceParams<Id: FheIntId> {
+    pub(crate) params: CompressedSignedRadixCiphertextConformanceParams,
+    pub(crate) id: PhantomData<Id>,
+}
+
+impl<Id: FheIntId, P: Into<AtomicPatternParameters>> From<P>
+    for CompressedFheIntConformanceParams<Id>
+{
+    fn from(params: P) -> Self {
+        let params = params.into();
+        Self {
+            params: CompressedSignedRadixCiphertextConformanceParams(
+                CompressedModulusSwitchedRadixCiphertextConformanceParams {
+                    shortint_params: params.to_compressed_modswitched_conformance_param(),
+                    num_blocks_per_integer: Id::num_blocks(params.message_modulus()),
+                },
+            ),
+            id: PhantomData,
+        }
+    }
+}
+
+impl<Id: FheIntId> From<&ServerKey> for CompressedFheIntConformanceParams<Id> {
+    fn from(sk: &ServerKey) -> Self {
+        Self {
+            params: CompressedSignedRadixCiphertextConformanceParams(
+                CompressedModulusSwitchedRadixCiphertextConformanceParams {
+                    shortint_params: sk
+                        .key
+                        .pbs_key()
+                        .key
+                        .compressed_modswitched_conformance_params(),
+                    num_blocks_per_integer: Id::num_blocks(sk.key.pbs_key().message_modulus()),
+                },
+            ),
+            id: PhantomData,
+        }
+    }
+}
+
 impl<Id: FheIntId> ParameterSetConformant for CompressedFheInt<Id> {
-    type ParameterSet = FheIntConformanceParams<Id>;
+    type ParameterSet = CompressedFheIntConformanceParams<Id>;
 
-    fn is_conformant(&self, params: &FheIntConformanceParams<Id>) -> bool {
+    fn is_conformant(&self, params: &CompressedFheIntConformanceParams<Id>) -> bool {
         let Self {
             ciphertext,
             id: _,
@@ -178,12 +221,17 @@ pub enum CompressedSignedRadixCiphertext {
     ModulusSwitched(CompressedModulusSwitchedSignedRadixCiphertext),
 }
 
+#[derive(Copy, Clone)]
+pub struct CompressedSignedRadixCiphertextConformanceParams(
+    pub(crate) CompressedModulusSwitchedRadixCiphertextConformanceParams,
+);
+
 impl ParameterSetConformant for CompressedSignedRadixCiphertext {
-    type ParameterSet = RadixCiphertextConformanceParams;
-    fn is_conformant(&self, params: &RadixCiphertextConformanceParams) -> bool {
+    type ParameterSet = CompressedSignedRadixCiphertextConformanceParams;
+    fn is_conformant(&self, params: &CompressedSignedRadixCiphertextConformanceParams) -> bool {
         match self {
-            Self::Seeded(ct) => ct.is_conformant(params),
-            Self::ModulusSwitched(ct) => ct.is_conformant(params),
+            Self::Seeded(ct) => ct.is_conformant(&params.0.into()),
+            Self::ModulusSwitched(ct) => ct.is_conformant(&params.0),
         }
     }
 }

tfhe/src/high_level_api/integers/signed/static_.rs

@@ -1,5 +1,7 @@
 use crate::high_level_api::integers::signed::base::{FheInt, FheIntConformanceParams, FheIntId};
-use crate::high_level_api::integers::signed::compressed::CompressedFheInt;
+use crate::high_level_api::integers::signed::compressed::{
+    CompressedFheInt, CompressedFheIntConformanceParams,
+};
 use crate::high_level_api::{FheId, IntegerId};
 use serde::{Deserialize, Serialize};
 use tfhe_versionable::NotVersioned;
@@ -52,6 +54,7 @@ macro_rules! static_int_type {
 
             // Conformance Params
             pub type [<FheInt $num_bits ConformanceParams>] = FheIntConformanceParams<[<FheInt $num_bits Id>]>;
+            pub type [<CompressedFheInt $num_bits ConformanceParams>] = CompressedFheIntConformanceParams<[<FheInt $num_bits Id>]>;
         }
     };
 }