Am/chore/update default params to ks32

.github/workflows/aws_tfhe_integer_tests.yml

@@ -125,13 +125,13 @@ jobs:
         run: |
           echo "NO_BIG_PARAMS=TRUE" >> "${GITHUB_ENV}"
 
-      - name: Gen Keys if required
-        run: |
-          make GEN_KEY_CACHE_MULTI_BIT_ONLY=TRUE gen_key_cache
+      # - name: Gen Keys if required
+      #   run: |
+      #     make GEN_KEY_CACHE_MULTI_BIT_ONLY=TRUE gen_key_cache
 
-      - name: Run unsigned integer multi-bit tests
-        run: |
-          AVX512_SUPPORT=ON make test_unsigned_integer_multi_bit_ci
+      # - name: Run unsigned integer multi-bit tests
+      #   run: |
+      #     AVX512_SUPPORT=ON make test_unsigned_integer_multi_bit_ci
 
       - name: Gen Keys if required
         run: |

.github/workflows/aws_tfhe_signed_integer_tests.yml

@@ -125,17 +125,17 @@ jobs:
         run: |
           echo "NO_BIG_PARAMS=TRUE" >> "${GITHUB_ENV}"
 
-      - name: Gen Keys if required
-        run: |
-          make GEN_KEY_CACHE_MULTI_BIT_ONLY=TRUE gen_key_cache
+      # - name: Gen Keys if required
+      #   run: |
+      #     make GEN_KEY_CACHE_MULTI_BIT_ONLY=TRUE gen_key_cache
 
-      - name: Run shortint multi-bit tests
-        run: |
-          make test_shortint_multi_bit_ci
+      # - name: Run shortint multi-bit tests
+      #   run: |
+      #     make test_shortint_multi_bit_ci
 
-      - name: Run signed integer multi-bit tests
-        run: |
-          AVX512_SUPPORT=ON make test_signed_integer_multi_bit_ci
+      # - name: Run signed integer multi-bit tests
+      #   run: |
+      #     AVX512_SUPPORT=ON make test_signed_integer_multi_bit_ci
 
       - name: Gen Keys if required
         run: |

tfhe/docs/references/fine-grained-apis/integer/operations.md

@@ -44,7 +44,7 @@ use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS;
 
 fn main() {
     let basis = vec![2, 3, 5];
-    let cks = CrtClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS, basis);
+    // let cks = CrtClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS, basis);
 }
 ```
 

tfhe/examples/utilities/generates_test_keys.rs

@@ -17,7 +17,8 @@ use tfhe::shortint::parameters::key_switching::ShortintKeySwitchingParameters;
 
 use tfhe::shortint::parameters::current_params::*;
 use tfhe::shortint::parameters::{
-    ClassicPBSParameters, PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128,
+    AtomicPatternParameters, ClassicPBSParameters, PARAM_MESSAGE_2_CARRY_2_KS32_PBS_TUNIFORM_2M128,
+    PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128,
 };
 #[cfg(feature = "experimental")]
 use tfhe::shortint::parameters::{
@@ -129,6 +130,8 @@ fn client_server_keys() {
         ];
         generate_pbs_keys(&PBS_KEYS);
 
+        generate_pbs_keys(&[PARAM_MESSAGE_2_CARRY_2_KS32_PBS_TUNIFORM_2M128]);
+
         #[cfg(feature = "experimental")]
         {
             const WOPBS_PARAMS: [(ClassicPBSParameters, WopbsParameters); 4] = [
@@ -155,10 +158,11 @@ fn client_server_keys() {
     }
 }
 
-fn generate_pbs_keys(params: &[ClassicPBSParameters]) {
+fn generate_pbs_keys<P: Into<AtomicPatternParameters> + Copy>(params: &[P]) {
     println!("Generating shortint (ClientKey, ServerKey)");
 
     for (i, param) in params.iter().copied().enumerate() {
+        let param: AtomicPatternParameters = param.into();
         println!(
             "Generating [{} / {}] : {}",
             i + 1,

tfhe/src/integer/public_key/standard.rs

@@ -118,14 +118,16 @@ mod tests {
     use crate::integer::keycache::KEY_CACHE;
     use crate::integer::tests::create_parameterized_test;
     use crate::integer::IntegerKeyKind;
-    use crate::shortint::parameters::test_params::TEST_PARAM_MESSAGE_2_CARRY_2_PBS_KS_GAUSSIAN_2M128;
-    use crate::shortint::parameters::ClassicPBSParameters;
+    use crate::shortint::parameters::test_params::{
+        TestParameters, TEST_PARAM_MESSAGE_2_CARRY_2_PBS_KS_GAUSSIAN_2M128,
+    };
 
     create_parameterized_test!(integer_public_key_decompression_small {
         TEST_PARAM_MESSAGE_2_CARRY_2_PBS_KS_GAUSSIAN_2M128,
     });
 
-    fn integer_public_key_decompression_small(param: ClassicPBSParameters) {
+    fn integer_public_key_decompression_small<P: Into<TestParameters>>(param: P) {
+        let param: TestParameters = param.into();
         let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::Radix);
 
         let compressed_pk = crate::integer::CompressedPublicKey::new(&cks);

tfhe/src/integer/public_key/tests.rs

@@ -60,12 +60,13 @@ create_parameterized_test!(
 
 /// Test that the public key can encrypt a 128 bit number
 /// in radix decomposition, and that the client key can decrypt it
-fn big_radix_encrypt_decrypt_128_bits(param: ClassicPBSParameters) {
+fn big_radix_encrypt_decrypt_128_bits<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     let (cks, _) = KEY_CACHE.get_from_params(param, IntegerKeyKind::Radix);
     let public_key = PublicKey::new(&cks);
 
     let mut rng = rand::thread_rng();
-    let num_block = (128f64 / (param.message_modulus.0 as f64).log(2.0)).ceil() as usize;
+    let num_block = (128f64 / (param.message_modulus().0 as f64).log(2.0)).ceil() as usize;
 
     let clear = rng.gen::<u128>();
 
@@ -76,12 +77,13 @@ fn big_radix_encrypt_decrypt_128_bits(param: ClassicPBSParameters) {
     assert_eq!(clear, dec);
 }
 
-fn radix_encrypt_decrypt_compressed_128_bits(param: ClassicPBSParameters) {
+fn radix_encrypt_decrypt_compressed_128_bits<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     let (cks, _) = KEY_CACHE.get_from_params(param, IntegerKeyKind::Radix);
     let public_key = CompressedPublicKey::new(&cks);
 
     let mut rng = rand::thread_rng();
-    let num_block = (128f64 / (param.message_modulus.0 as f64).log(2.0)).ceil() as usize;
+    let num_block = (128f64 / (param.message_modulus().0 as f64).log(2.0)).ceil() as usize;
 
     let clear = rng.gen::<u128>();
 

tfhe/src/integer/server_key/crt/tests.rs

@@ -227,14 +227,15 @@ fn integer_unchecked_crt_scalar_sub_32_bits() {
     }
 }
 
-fn integer_unchecked_crt_mul(param: ClassicPBSParameters) {
+fn integer_unchecked_crt_mul<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     // generate the server-client key set
     let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::CRT);
 
     let mut rng = rand::thread_rng();
 
     // Define CRT basis, and global modulus
-    let basis = make_basis(param.message_modulus.0);
+    let basis = make_basis(param.message_modulus().0);
     let modulus = basis.iter().product::<u64>();
 
     for _ in 0..NB_TESTS {
@@ -253,9 +254,10 @@ fn integer_unchecked_crt_mul(param: ClassicPBSParameters) {
     }
 }
 
-fn integer_smart_crt_add(param: ClassicPBSParameters) {
+fn integer_smart_crt_add<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     // Define CRT basis, and global modulus
-    let basis = make_basis(param.message_modulus.0);
+    let basis = make_basis(param.message_modulus().0);
     let modulus = basis.iter().product::<u64>();
 
     let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::CRT);
@@ -279,12 +281,13 @@ fn integer_smart_crt_add(param: ClassicPBSParameters) {
     }
 }
 
-fn integer_smart_crt_mul(param: ClassicPBSParameters) {
+fn integer_smart_crt_mul<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     // generate the server-client key set
     let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::CRT);
 
     // Define CRT basis, and global modulus
-    let basis = make_basis(param.message_modulus.0);
+    let basis = make_basis(param.message_modulus().0);
     let modulus = basis.iter().product::<u64>();
 
     println!("BASIS = {basis:?}");
@@ -308,9 +311,10 @@ fn integer_smart_crt_mul(param: ClassicPBSParameters) {
     }
 }
 
-fn integer_smart_crt_neg(param: ClassicPBSParameters) {
+fn integer_smart_crt_neg<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     // Define CRT basis, and global modulus
-    let basis = make_basis(param.message_modulus.0);
+    let basis = make_basis(param.message_modulus().0);
     let modulus = basis.iter().product::<u64>();
 
     let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::CRT);
@@ -334,9 +338,10 @@ fn integer_smart_crt_neg(param: ClassicPBSParameters) {
     }
 }
 
-fn integer_smart_crt_scalar_add(param: ClassicPBSParameters) {
+fn integer_smart_crt_scalar_add<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     // Define CRT basis, and global modulus
-    let basis = make_basis(param.message_modulus.0);
+    let basis = make_basis(param.message_modulus().0);
     let modulus = basis.iter().product::<u64>();
 
     let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::CRT);
@@ -358,9 +363,10 @@ fn integer_smart_crt_scalar_add(param: ClassicPBSParameters) {
     }
 }
 
-fn integer_smart_crt_scalar_mul(param: ClassicPBSParameters) {
+fn integer_smart_crt_scalar_mul<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     // Define CRT basis, and global modulus
-    let basis = make_basis(param.message_modulus.0);
+    let basis = make_basis(param.message_modulus().0);
     let modulus = basis.iter().product::<u64>();
 
     let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::CRT);
@@ -382,9 +388,10 @@ fn integer_smart_crt_scalar_mul(param: ClassicPBSParameters) {
     }
 }
 
-fn integer_smart_crt_scalar_sub(param: ClassicPBSParameters) {
+fn integer_smart_crt_scalar_sub<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     // Define CRT basis, and global modulus
-    let basis = make_basis(param.message_modulus.0);
+    let basis = make_basis(param.message_modulus().0);
     let modulus = basis.iter().product::<u64>();
 
     let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::CRT);
@@ -409,9 +416,10 @@ fn integer_smart_crt_scalar_sub(param: ClassicPBSParameters) {
     }
 }
 
-fn integer_smart_crt_sub(param: ClassicPBSParameters) {
+fn integer_smart_crt_sub<P: Into<TestParameters>>(param: P) {
+    let param: TestParameters = param.into();
     // Define CRT basis, and global modulus
-    let basis = make_basis(param.message_modulus.0);
+    let basis = make_basis(param.message_modulus().0);
     let modulus = basis.iter().product::<u64>();
 
     let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::CRT);