Struct CrtMultiServerKey 

pub struct CrtMultiServerKey { /* private fields */ }

Implementations

impl CrtMultiServerKey

pub fn new_many_keys(cks: &CrtMultiClientKey) -> CrtMultiServerKey

Allocates and generates a server key.

Example

use concrete_integer::{CrtMultiClientKey, CrtMultiServerKey};
use concrete_shortint::parameters::{PARAM_MESSAGE_1_CARRY_1, PARAM_MESSAGE_2_CARRY_2};

// Generate the client key:
let cks = CrtMultiClientKey::new_many_keys(&[PARAM_MESSAGE_1_CARRY_1, PARAM_MESSAGE_2_CARRY_2]);
let sks = CrtMultiServerKey::new_many_keys(&cks);

pub fn unchecked_add_crt_many_keys_assign( &self, ct_left: &mut CrtMultiCiphertext, ct_right: &mut CrtMultiCiphertext, )

Computes an homomorphic addition.

Example

 use concrete_integer::{gen_key_id, gen_keys_multi_crt};
 use concrete_shortint::parameters::{PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_1};

 // Generate the client key and the server key:
 let (cks, sks) = gen_keys_multi_crt(&[PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_1]);

 let clear_1 = 14;
 let clear_2 = 11;

 let basis = vec![2, 3, 7];
 let keys_id = gen_key_id(&[0, 0, 1]);

 // Encrypt two messages
 let mut ctxt_1 = cks.encrypt(&clear_1, &basis, &keys_id);
 let mut ctxt_2 = cks.encrypt(&clear_2, &basis, &keys_id);

 sks.unchecked_add_crt_many_keys_assign(&mut ctxt_1, &mut ctxt_2);

 // Decrypt
 let res = cks.decrypt(&ctxt_1);
 assert_eq!((clear_1 + clear_2) % 30, res);

pub fn unchecked_add_crt_many_keys_assign_parallelized( &self, ct_left: &mut CrtMultiCiphertext, ct_right: &mut CrtMultiCiphertext, )

Computes an homomorphic addition.

Warning

Multithreaded

Example

 use concrete_integer::{gen_key_id, gen_keys_multi_crt};
 use concrete_shortint::parameters::{PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_1};

 // Generate the client key and the server key:
 let (cks, sks) = gen_keys_multi_crt(&[PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_1]);

 let clear_1 = 14;
 let clear_2 = 11;

 let basis = vec![2, 3, 7];
 let keys_id = gen_key_id(&[0, 0, 1]);

 // Encrypt two messages
 let mut ctxt_1 = cks.encrypt(&clear_1, &basis, &keys_id);
 let mut ctxt_2 = cks.encrypt(&clear_2, &basis, &keys_id);

 sks.unchecked_add_crt_many_keys_assign_parallelized(&mut ctxt_1, &mut ctxt_2);

 // Decrypt
 let res = cks.decrypt(&ctxt_1);
 assert_eq!((clear_1 + clear_2) % 30, res);

pub fn unchecked_mul_crt_many_keys_assign( &self, ct_left: &mut CrtMultiCiphertext, ct_right: &mut CrtMultiCiphertext, )

Computes an homomorphic multiplication.

Example

 use concrete_integer::{gen_key_id, gen_keys_multi_crt};
 use concrete_shortint::parameters::{
     PARAM_MESSAGE_1_CARRY_1, PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_3,
 };

 // Generate the client key and the server key:
 let (cks, sks) = gen_keys_multi_crt(&vec![
     PARAM_MESSAGE_1_CARRY_1,
     PARAM_MESSAGE_2_CARRY_2,
     PARAM_MESSAGE_3_CARRY_3,
 ]);

 let clear_1 = 13;
 let clear_2 = 11;

 let basis = vec![2, 3, 5];
 let keys_id = gen_key_id(&[0, 1, 2]);

 // Encrypt two messages
 let mut ctxt_1 = cks.encrypt(&clear_1, &basis, &keys_id);
 let mut ctxt_2 = cks.encrypt(&clear_2, &basis, &keys_id);

 sks.unchecked_mul_crt_many_keys_assign(&mut ctxt_1, &mut ctxt_2);

 // Decrypt
 let res = cks.decrypt(&ctxt_1);
 assert_eq!((clear_1 * clear_2) % 30, res);

pub fn unchecked_mul_crt_many_keys_assign_parallelized( &self, ct_left: &mut CrtMultiCiphertext, ct_right: &mut CrtMultiCiphertext, )

Computes an homomorphic multiplication.

Warning

Multithreaded

Example

 use concrete_integer::{gen_key_id, gen_keys_multi_crt};
 use concrete_shortint::parameters::{
     PARAM_MESSAGE_1_CARRY_1, PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_3,
 };

 // Generate the client key and the server key:
 let (cks, sks) = gen_keys_multi_crt(&vec![
     PARAM_MESSAGE_1_CARRY_1,
     PARAM_MESSAGE_2_CARRY_2,
     PARAM_MESSAGE_3_CARRY_3,
 ]);

 let clear_1 = 13;
 let clear_2 = 11;

 let basis = vec![2, 3, 5];
 let keys_id = gen_key_id(&[0, 1, 2]);

 // Encrypt two messages
 let mut ctxt_1 = cks.encrypt(&clear_1, &basis, &keys_id);
 let mut ctxt_2 = cks.encrypt(&clear_2, &basis, &keys_id);

 sks.unchecked_mul_crt_many_keys_assign_parallelized(&mut ctxt_1, &mut ctxt_2);

 // Decrypt
 let res = cks.decrypt(&ctxt_1);
 assert_eq!((clear_1 * clear_2) % 30, res);

pub fn arithmetic_function_crt_many_keys_assign<F>( &self, ct: &mut CrtMultiCiphertext, f: F, )

where F: Fn(u64) -> u64,

Computes an homomorphic evaluation of an CRT-compliant univariate function.

Warning The function has to be CRT-compliant.

Example

 use concrete_integer::{gen_key_id, gen_keys_multi_crt};
 use concrete_shortint::parameters::{
     PARAM_MESSAGE_1_CARRY_1, PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_3,
 };

 // Generate the client key and the server key:
 let (cks, sks) = gen_keys_multi_crt(&vec![
     PARAM_MESSAGE_1_CARRY_1,
     PARAM_MESSAGE_2_CARRY_2,
     PARAM_MESSAGE_3_CARRY_3,
 ]);

 let clear_1 = 14;
 let clear_2 = 11;

 let basis = vec![2, 3, 5];
 let keys_id = gen_key_id(&[0, 1, 2]);

 // Encrypt two messages
 let mut ctxt_1 = cks.encrypt(&clear_1, &basis, &keys_id);
 let mut ctxt_2 = cks.encrypt(&clear_2, &basis, &keys_id);

 sks.arithmetic_function_crt_many_keys_assign(&mut ctxt_1, |x| x * x);

 // Decrypt
 let res = cks.decrypt(&ctxt_1);
 assert_eq!((clear_1 * clear_1) % 30, res);

pub fn arithmetic_function_crt_many_keys_assign_parallelized<F>( &self, ct: &mut CrtMultiCiphertext, f: F, )

where F: Fn(u64) -> u64,

Computes an homomorphic evaluation of an CRT-compliant univariate function.

Warning

• Multithreaded
• The function has to be CRT-compliant.

Example

 use concrete_integer::{gen_key_id, gen_keys_multi_crt};
 use concrete_shortint::parameters::{
     PARAM_MESSAGE_1_CARRY_1, PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_3,
 };

 // Generate the client key and the server key:
 let (cks, sks) = gen_keys_multi_crt(&vec![
     PARAM_MESSAGE_1_CARRY_1,
     PARAM_MESSAGE_2_CARRY_2,
     PARAM_MESSAGE_3_CARRY_3,
 ]);

 let clear_1 = 14;
 let clear_2 = 11;

 let basis = vec![2, 3, 5];
 let keys_id = gen_key_id(&[0, 1, 2]);

 // Encrypt two messages
 let mut ctxt_1 = cks.encrypt(&clear_1, &basis, &keys_id);
 let mut ctxt_2 = cks.encrypt(&clear_2, &basis, &keys_id);

 sks.arithmetic_function_crt_many_keys_assign_parallelized(&mut ctxt_1, |x| x * x);

 // Decrypt
 let res = cks.decrypt(&ctxt_1);
 assert_eq!((clear_1 * clear_1) % 30, res);

Trait Implementations

impl Clone for CrtMultiServerKey

fn clone(&self) -> CrtMultiServerKey

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CrtMultiServerKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CrtMultiServerKey

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Vec<ServerKey>> for CrtMultiServerKey

fn from(keys: Vec<ServerKey>) -> Self

Converts to this type from the input type.

impl Serialize for CrtMultiServerKey

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.