Struct CrtMultiClientKey 

pub struct CrtMultiClientKey { /* private fields */ }

Client key for CRT decomposition.

As opposed to crate::ClientKey and crate::CrtClientKey, not all blocks in the ciphertext will use the same parameters.

Implementations

impl CrtMultiClientKey

pub fn new_many_keys(parameter_set: &[Parameters]) -> CrtMultiClientKey

Create a client key.

Example

use concrete_integer::CrtMultiClientKey;
use concrete_shortint::parameters::{
    DEFAULT_PARAMETERS, PARAM_MESSAGE_2_CARRY_2, PARAM_MESSAGE_3_CARRY_3,
};

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

pub fn encrypt( &self, message: &u64, base_vec: &[u64], keys_id: &[KeyId], ) -> CrtMultiCiphertext

Encrypts an integer using the CRT decomposition, where each block is associated to dedicated key.

Example

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

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

let msg = 15_u64;

// Encryption of one message:
let basis: Vec<u64> = vec![2, 3, 5];
// The first two blocks are encrypted using the first key,
// the third block with the second key
let keys_id = gen_key_id(&[0, 0, 1]);
let ct = cks.encrypt(&msg, &basis, &keys_id);

// Decryption:
let dec = cks.decrypt(&ct);
assert_eq!(msg, dec);

pub fn decrypt(&self, ctxt: &CrtMultiCiphertext) -> u64

Decrypts an integer in the multi-key CRT settings.

Example

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

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

let msg = 27_u64;

// Encryption of one message:
let basis: Vec<u64> = vec![2, 3, 5];
// The first two blocks are encrypted using the first key,
// the third block with the second key
let keys_id = gen_key_id(&[0, 0, 1]);
let ct = cks.encrypt(&msg, &basis, &keys_id);

// Decryption:
let dec = cks.decrypt(&ct);
assert_eq!(msg, dec);

Trait Implementations

impl Clone for CrtMultiClientKey

fn clone(&self) -> CrtMultiClientKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CrtMultiClientKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CrtMultiClientKey

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Vec<ClientKey>> for CrtMultiClientKey

Creates a CrtMultiClientKey from a vector of shortint keys.

Each key will encrypt one block (in order).

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

Converts to this type from the input type.

impl PartialEq for CrtMultiClientKey

fn eq(&self, other: &CrtMultiClientKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CrtMultiClientKey

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CrtMultiClientKey