Struct concrete_core::backends::default::entities::LweSecretKey32

pub struct LweSecretKey32(_);

A structure representing an LWE secret key with 32 bits of precision.

Trait Implementations

impl AbstractEntity for LweSecretKey32

type Kind = LweSecretKeyKind

The kind of the entity.

impl Clone for LweSecretKey32

fn clone(&self) -> LweSecretKey32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LweSecretKey32

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

Formats the value using the given formatter.

impl EntityDeserializationEngine<&[u8], LweSecretKey32> for DefaultSerializationEngine

Description:

Implementation of EntityDeserializationEngine for DefaultSerializationEngine that operates on 32 bits integers. It deserializes a LWE secret key entity.

fn deserialize(
    &mut self,
    serialized: &[u8]
) -> Result<LweSecretKey32, EntityDeserializationError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_secret_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;

let mut serialization_engine = DefaultSerializationEngine::new(())?;
let serialized = serialization_engine.serialize(&lwe_secret_key)?;
let recovered = serialization_engine.deserialize(serialized.as_slice())?;
assert_eq!(lwe_secret_key, recovered);

unsafe fn deserialize_unchecked(&mut self, serialized: &[u8]) -> LweSecretKey32

Unsafely deserializes an entity.

impl EntitySerializationEngine<LweSecretKey32, Vec<u8, Global>> for DefaultSerializationEngine

Description:

Implementation of EntitySerializationEngine for DefaultSerializationEngine that operates on 32 bits integers. It serializes a LWE secret key entity.

fn serialize(
    &mut self,
    entity: &LweSecretKey32
) -> Result<Vec<u8>, EntitySerializationError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_secret_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;

let mut serialization_engine = DefaultSerializationEngine::new(())?;
let serialized = serialization_engine.serialize(&lwe_secret_key)?;
let recovered = serialization_engine.deserialize(serialized.as_slice())?;
assert_eq!(lwe_secret_key, recovered);

unsafe fn serialize_unchecked(&mut self, entity: &LweSecretKey32) -> Vec<u8>

Unsafely serializes an entity.

impl GlweToLweSecretKeyTransformationEngine<GlweSecretKey32, LweSecretKey32> for DefaultEngine

fn transform_glwe_secret_key_to_lwe_secret_key(
    &mut self,
    glwe_secret_key: GlweSecretKey32
) -> Result<LweSecretKey32, GlweToLweSecretKeyTransformationError<Self::EngineError>>

Example

use concrete_core::prelude::{GlweDimension, LweDimension, PolynomialSize, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;

let glwe_secret_key: GlweSecretKey32 =
    engine.generate_new_glwe_secret_key(glwe_dimension, polynomial_size)?;
assert_eq!(glwe_secret_key.glwe_dimension(), glwe_dimension);
assert_eq!(glwe_secret_key.polynomial_size(), polynomial_size);

let lwe_secret_key = engine.transform_glwe_secret_key_to_lwe_secret_key(glwe_secret_key)?;
assert_eq!(lwe_secret_key.lwe_dimension(), LweDimension(8));

unsafe fn transform_glwe_secret_key_to_lwe_secret_key_unchecked(
    &mut self,
    glwe_secret_key: GlweSecretKey32
) -> LweSecretKey32

Unsafely transforms a GLWE secret key into an LWE secret key

impl LweBootstrapKeyGenerationEngine<LweSecretKey32, GlweSecretKey32, LweBootstrapKey32> for DefaultEngine

Description:

Implementation of LweBootstrapKeyGenerationEngine for DefaultEngine that operates on 32 bits integers. It outputs a bootstrap key in the standard domain.

fn generate_new_lwe_bootstrap_key(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> Result<LweBootstrapKey32, LweBootstrapKeyGenerationError<Self::EngineError>>

Example

use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, GlweDimension, LweDimension, PolynomialSize,
    Variance, *,
};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let (lwe_dim, glwe_dim, poly_size) = (LweDimension(4), GlweDimension(6), PolynomialSize(256));
let (dec_lc, dec_bl) = (DecompositionLevelCount(3), DecompositionBaseLog(5));
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_sk: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey32 = engine.generate_new_glwe_secret_key(glwe_dim, poly_size)?;

let bsk: LweBootstrapKey32 =
    engine.generate_new_lwe_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;
assert_eq!(bsk.glwe_dimension(), glwe_dim);
assert_eq!(bsk.polynomial_size(), poly_size);
assert_eq!(bsk.input_lwe_dimension(), lwe_dim);
assert_eq!(bsk.decomposition_base_log(), dec_bl);
assert_eq!(bsk.decomposition_level_count(), dec_lc);

unsafe fn generate_new_lwe_bootstrap_key_unchecked(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> LweBootstrapKey32

Unsafely generates a new LWE bootstrap key.

impl LweBootstrapKeyGenerationEngine<LweSecretKey32, GlweSecretKey32, LweBootstrapKey32> for DefaultParallelEngine

Description:

Implementation of LweBootstrapKeyGenerationEngine for DefaultParallelEngine that operates on 32 bits integers. It outputs a bootstrap key in the standard domain.

fn generate_new_lwe_bootstrap_key(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> Result<LweBootstrapKey32, LweBootstrapKeyGenerationError<Self::EngineError>>

Example

use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, GlweDimension, LweDimension, PolynomialSize,
    Variance, *,
};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let (lwe_dim, glwe_dim, poly_size) = (LweDimension(4), GlweDimension(6), PolynomialSize(256));
let (dec_lc, dec_bl) = (DecompositionLevelCount(3), DecompositionBaseLog(5));
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut default_engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let mut default_parallel_engine =
    DefaultParallelEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_sk: LweSecretKey32 = default_engine.generate_new_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey32 =
    default_engine.generate_new_glwe_secret_key(glwe_dim, poly_size)?;

let bsk: LweBootstrapKey32 = default_parallel_engine
    .generate_new_lwe_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;
assert_eq!(bsk.glwe_dimension(), glwe_dim);
assert_eq!(bsk.polynomial_size(), poly_size);
assert_eq!(bsk.input_lwe_dimension(), lwe_dim);
assert_eq!(bsk.decomposition_base_log(), dec_bl);
assert_eq!(bsk.decomposition_level_count(), dec_lc);

unsafe fn generate_new_lwe_bootstrap_key_unchecked(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> LweBootstrapKey32

Unsafely generates a new LWE bootstrap key.

impl LweCiphertextDecryptionEngine<LweSecretKey32, LweCiphertext32, Plaintext32> for DefaultEngine

Description:

Implementation of LweCiphertextDecryptionEngine for DefaultEngine that operates on 32 bits integers.

fn decrypt_lwe_ciphertext(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertext32
) -> Result<Plaintext32, LweCiphertextDecryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = 3_u32 << 20;
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;
let ciphertext = engine.encrypt_lwe_ciphertext(&key, &plaintext, noise)?;

let decrypted_plaintext = engine.decrypt_lwe_ciphertext(&key, &ciphertext)?;

unsafe fn decrypt_lwe_ciphertext_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertext32
) -> Plaintext32

Unsafely decrypts an LWE ciphertext.

impl LweCiphertextDecryptionEngine<LweSecretKey32, LweCiphertextView32<'_>, Plaintext32> for DefaultEngine

Description:

Implementation of LweCiphertextDecryptionEngine for DefaultEngine that operates on an LweCiphertextView32 containing 32 bits integers.

fn decrypt_lwe_ciphertext(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertextView32<'_>
) -> Result<Plaintext32, LweCiphertextDecryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = 3_u32 << 20;
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let mut raw_ciphertext = vec![0_u32; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_view: LweCiphertextMutView32 =
    engine.create_lwe_ciphertext_from(&mut raw_ciphertext[..])?;
engine.discard_encrypt_lwe_ciphertext(&key, &mut ciphertext_view, &plaintext, noise)?;

// Convert MutView to View
let raw_ciphertext = engine.consume_retrieve_lwe_ciphertext(ciphertext_view)?;
let ciphertext_view: LweCiphertextView32 =
    engine.create_lwe_ciphertext_from(&raw_ciphertext[..])?;

let decrypted_plaintext = engine.decrypt_lwe_ciphertext(&key, &ciphertext_view)?;

unsafe fn decrypt_lwe_ciphertext_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertextView32<'_>
) -> Plaintext32

Unsafely decrypts an LWE ciphertext.

impl LweCiphertextDiscardingDecryptionEngine<LweSecretKey32, LweCiphertext32, Plaintext32> for DefaultEngine

Description:

Implementation of LweCiphertextDiscardingDecryptionEngine for DefaultEngine that operates on 32 bits integers.

fn discard_decrypt_lwe_ciphertext(
    &mut self,
    key: &LweSecretKey32,
    output: &mut Plaintext32,
    input: &LweCiphertext32
) -> Result<(), LweCiphertextDiscardingDecryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = 3_u32 << 20;
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let mut plaintext = engine.create_plaintext_from(&input)?;
let ciphertext = engine.encrypt_lwe_ciphertext(&key, &plaintext, noise)?;

engine.discard_decrypt_lwe_ciphertext(&key, &mut plaintext, &ciphertext)?;
assert_eq!(ciphertext.lwe_dimension(), lwe_dimension);

unsafe fn discard_decrypt_lwe_ciphertext_unchecked(
    &mut self,
    key: &LweSecretKey32,
    output: &mut Plaintext32,
    input: &LweCiphertext32
)

Unsafely decrypts an LWE ciphertext.

impl LweCiphertextDiscardingEncryptionEngine<LweSecretKey32, Plaintext32, LweCiphertext32> for DefaultEngine

Description:

Implementation of LweCiphertextDiscardingEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn discard_encrypt_lwe_ciphertext(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertext32,
    input: &Plaintext32,
    noise: Variance
) -> Result<(), LweCiphertextDiscardingEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = 3_u32 << 20;
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;
let mut ciphertext = engine.encrypt_lwe_ciphertext(&key, &plaintext, noise)?;

engine.discard_encrypt_lwe_ciphertext(&key, &mut ciphertext, &plaintext, noise)?;
assert_eq!(ciphertext.lwe_dimension(), lwe_dimension);

unsafe fn discard_encrypt_lwe_ciphertext_unchecked(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertext32,
    input: &Plaintext32,
    noise: Variance
)

Unsafely encrypts an LWE ciphertext.

impl LweCiphertextDiscardingEncryptionEngine<LweSecretKey32, Plaintext32, LweCiphertextMutView32<'_>> for DefaultEngine

Description:

Implementation of LweCiphertextDiscardingEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn discard_encrypt_lwe_ciphertext(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertextMutView32<'_>,
    input: &Plaintext32,
    noise: Variance
) -> Result<(), LweCiphertextDiscardingEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = 3_u32 << 20;
let noise = Variance(2_f64.powf(-25.));

// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let mut output_cipertext_container = vec![0_32; lwe_dimension.to_lwe_size().0];
let mut output_ciphertext: LweCiphertextMutView32 =
    engine.create_lwe_ciphertext_from(&mut output_cipertext_container[..])?;

engine.discard_encrypt_lwe_ciphertext(&key, &mut output_ciphertext, &plaintext, noise)?;
assert_eq!(output_ciphertext.lwe_dimension(), lwe_dimension);

unsafe fn discard_encrypt_lwe_ciphertext_unchecked(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertextMutView32<'_>,
    input: &Plaintext32,
    noise: Variance
)

Unsafely encrypts an LWE ciphertext.

impl LweCiphertextEncryptionEngine<LweSecretKey32, Plaintext32, LweCiphertext32> for DefaultEngine

Description:

Implementation of LweCiphertextEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn encrypt_lwe_ciphertext(
    &mut self,
    key: &LweSecretKey32,
    input: &Plaintext32,
    noise: Variance
) -> Result<LweCiphertext32, LweCiphertextEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = 3_u32 << 20;
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let ciphertext = engine.encrypt_lwe_ciphertext(&key, &plaintext, noise)?;
assert_eq!(ciphertext.lwe_dimension(), lwe_dimension);

unsafe fn encrypt_lwe_ciphertext_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &Plaintext32,
    noise: Variance
) -> LweCiphertext32

Unsafely encrypts an LWE ciphertext.

impl LweCiphertextVectorDecryptionEngine<LweSecretKey32, LweCiphertextVector32, PlaintextVector32> for DefaultEngine

Description:

Implementation of LweCiphertextVectorDecryptionEngine for DefaultEngine that operates on 32 bits integers.

fn decrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertextVector32
) -> Result<PlaintextVector32, LweCiphertextVectorDecryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweCiphertextCount, LweDimension, PlaintextCount, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 18];
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector_from(&input)?;
let ciphertext_vector: LweCiphertextVector32 =
    engine.encrypt_lwe_ciphertext_vector(&key, &plaintext_vector, noise)?;

let decrypted_plaintext_vector =
    engine.decrypt_lwe_ciphertext_vector(&key, &ciphertext_vector)?;

assert_eq!(
    decrypted_plaintext_vector.plaintext_count(),
    PlaintextCount(18)
);

unsafe fn decrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertextVector32
) -> PlaintextVector32

Unsafely decrypts an LWE ciphertext vector.

impl LweCiphertextVectorDecryptionEngine<LweSecretKey32, LweCiphertextVectorView32<'_>, PlaintextVector32> for DefaultEngine

Description:

Implementation of LweCiphertextVectorDecryptionEngine for DefaultEngine that operates on 32 bits integers.

fn decrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertextVectorView32<'_>
) -> Result<PlaintextVector32, LweCiphertextVectorDecryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
let lwe_count = LweCiphertextCount(18);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; lwe_count.0];
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext_vector = engine.create_plaintext_vector_from(&input)?;

let mut raw_ciphertext_vector = vec![0_u32; key.lwe_dimension().to_lwe_size().0 * lwe_count.0];
let mut ciphertext_vector_view: LweCiphertextVectorMutView32 = engine
    .create_lwe_ciphertext_vector_from(
        &mut raw_ciphertext_vector[..],
        lwe_dimension.to_lwe_size(),
    )?;
engine.discard_encrypt_lwe_ciphertext_vector(
    &key,
    &mut ciphertext_vector_view,
    &plaintext_vector,
    noise,
)?;

// Convert MutView to View
let raw_ciphertext_vector =
    engine.consume_retrieve_lwe_ciphertext_vector(ciphertext_vector_view)?;
let ciphertext_vector_view: LweCiphertextVectorView32 = engine
    .create_lwe_ciphertext_vector_from(
        &raw_ciphertext_vector[..],
        lwe_dimension.to_lwe_size(),
    )?;

let decrypted_plaintext_vector =
    engine.decrypt_lwe_ciphertext_vector(&key, &ciphertext_vector_view)?;

assert_eq!(
    decrypted_plaintext_vector.plaintext_count(),
    PlaintextCount(lwe_count.0)
);

unsafe fn decrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertextVectorView32<'_>
) -> PlaintextVector32

Unsafely decrypts an LWE ciphertext vector.

impl LweCiphertextVectorDiscardingDecryptionEngine<LweSecretKey32, LweCiphertextVector32, PlaintextVector32> for DefaultEngine

Description:

Implementation of LweCiphertextVectorDiscardingDecryptionEngine for DefaultEngine that operates on 32 bits integers.

fn discard_decrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    output: &mut PlaintextVector32,
    input: &LweCiphertextVector32
) -> Result<(), LweCiphertextVectorDiscardingDecryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweCiphertextCount, LweDimension, PlaintextCount, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 18];
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let mut plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector_from(&input)?;
let ciphertext_vector: LweCiphertextVector32 =
    engine.encrypt_lwe_ciphertext_vector(&key, &plaintext_vector, noise)?;

engine.discard_decrypt_lwe_ciphertext_vector(
    &key,
    &mut plaintext_vector,
    &ciphertext_vector,
)?;
assert_eq!(plaintext_vector.plaintext_count(), PlaintextCount(18));

unsafe fn discard_decrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    output: &mut PlaintextVector32,
    input: &LweCiphertextVector32
)

Unsafely decrypts an LWE ciphertext vector.

impl LweCiphertextVectorDiscardingEncryptionEngine<LweSecretKey32, PlaintextVector32, LweCiphertextVector32> for DefaultEngine

Description:

Implementation of LweCiphertextVectorDiscardingEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn discard_encrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertextVector32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<(), LweCiphertextVectorDiscardingEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{LweCiphertextCount, LweDimension};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 3];
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector_from(&input)?;
let mut ciphertext_vector: LweCiphertextVector32 =
    engine.zero_encrypt_lwe_ciphertext_vector(&key, noise, LweCiphertextCount(3))?;

engine.discard_encrypt_lwe_ciphertext_vector(
    &key,
    &mut ciphertext_vector,
    &plaintext_vector,
    noise,
)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(

unsafe fn discard_encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertextVector32,
    input: &PlaintextVector32,
    noise: Variance
)

Unsafely encryprs an LWE ciphertext vector.

impl LweCiphertextVectorDiscardingEncryptionEngine<LweSecretKey32, PlaintextVector32, LweCiphertextVectorMutView32<'_>> for DefaultEngine

Description:

Implementation of LweCiphertextVectorDiscardingEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn discard_encrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertextVectorMutView32<'_>,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<(), LweCiphertextVectorDiscardingEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
let lwe_count = LweCiphertextCount(3);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; lwe_count.0];
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector_from(&input)?;

let mut output_ciphertext_vector_container = vec![0_32; lwe_dimension.to_lwe_size().0 *
    lwe_count.0];
let mut ciphertext_vector: LweCiphertextVectorMutView32 =
    engine.create_lwe_ciphertext_vector_from(&mut output_ciphertext_vector_container[..],
    lwe_dimension.to_lwe_size())?;

engine.discard_encrypt_lwe_ciphertext_vector(&key, &mut ciphertext_vector,
    &plaintext_vector, noise)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(

unsafe fn discard_encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertextVectorMutView32<'_>,
    input: &PlaintextVector32,
    noise: Variance
)

Unsafely encryprs an LWE ciphertext vector.

impl LweCiphertextVectorEncryptionEngine<LweSecretKey32, PlaintextVector32, LweCiphertextVector32> for DefaultEngine

Description:

Implementation of LweCiphertextVectorEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn encrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<LweCiphertextVector32, LweCiphertextVectorEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{LweCiphertextCount, LweDimension};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 3];
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector_from(&input)?;

let mut ciphertext_vector: LweCiphertextVector32 =
    engine.encrypt_lwe_ciphertext_vector(&key, &plaintext_vector, noise)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(

unsafe fn encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> LweCiphertextVector32

Unsafely encrypts an LWE ciphertext vector.

impl LweCiphertextVectorZeroEncryptionEngine<LweSecretKey32, LweCiphertextVector32> for DefaultEngine

Description:

Implementation of LweCiphertextVectorZeroEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn zero_encrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    noise: Variance,
    count: LweCiphertextCount
) -> Result<LweCiphertextVector32, LweCiphertextVectorZeroEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweCiphertextCount, LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
let ciphertext_count = LweCiphertextCount(3);
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;

let ciphertext_vector =
    engine.zero_encrypt_lwe_ciphertext_vector(&key, noise, ciphertext_count)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(ciphertext_vector.lwe_ciphertext_count(), ciphertext_count);

unsafe fn zero_encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    noise: Variance,
    count: LweCiphertextCount
) -> LweCiphertextVector32

Unsafely encrypts zeros in an LWE ciphertext vector.

impl LweCiphertextVectorZeroEncryptionEngine<LweSecretKey32, LweCiphertextVector32> for DefaultParallelEngine

Description:

Implementation of LweCiphertextVectorZeroEncryptionEngine for DefaultParallelEngine that operates on 32 bits integers.

fn zero_encrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    noise: Variance,
    count: LweCiphertextCount
) -> Result<LweCiphertextVector32, LweCiphertextVectorZeroEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweCiphertextCount, LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
let ciphertext_count = LweCiphertextCount(3);
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let mut par_engine = DefaultParallelEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;

let ciphertext_vector =
    par_engine.zero_encrypt_lwe_ciphertext_vector(&key, noise, ciphertext_count)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(ciphertext_vector.lwe_ciphertext_count(), ciphertext_count);

unsafe fn zero_encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    noise: Variance,
    count: LweCiphertextCount
) -> LweCiphertextVector32

Unsafely encrypts zeros in an LWE ciphertext vector.

impl LweCiphertextZeroEncryptionEngine<LweSecretKey32, LweCiphertext32> for DefaultEngine

Description:

Implementation of LweCiphertextZeroEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn zero_encrypt_lwe_ciphertext(
    &mut self,
    key: &LweSecretKey32,
    noise: Variance
) -> Result<LweCiphertext32, LweCiphertextZeroEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;

let ciphertext = engine.zero_encrypt_lwe_ciphertext(&key, noise)?;
assert_eq!(ciphertext.lwe_dimension(), lwe_dimension);

unsafe fn zero_encrypt_lwe_ciphertext_unchecked(
    &mut self,
    key: &LweSecretKey32,
    noise: Variance
) -> LweCiphertext32

Safely encrypts zero into an LWE ciphertext.

impl LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeysGenerationEngine<LweSecretKey32, GlweSecretKey32, LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys32> for DefaultEngine

Description:

Implementation of LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeysGenerationEngine for DefaultEngine that operates on 32 bits integers.

fn generate_new_lwe_circuit_bootstrap_private_functional_packing_keyswitch_keys(
    &mut self,
    input_lwe_key: &LweSecretKey32,
    output_glwe_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> Result<LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys32, LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeysGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, LweDimension, GlweDimension,FunctionalPackingKeyswitchKeyCount
};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(10);
let output_glwe_dimension = GlweDimension(3);
let polynomial_size = PolynomialSize(256);
let decomposition_base_log = DecompositionBaseLog(3);
let decomposition_level_count = DecompositionLevelCount(5);
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let input_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: GlweSecretKey32 = engine.generate_new_glwe_secret_key(output_glwe_dimension,
polynomial_size)?;

let cbs_private_functional_packing_keyswitch_key:
    LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys32 =
    engine
    .generate_new_lwe_circuit_bootstrap_private_functional_packing_keyswitch_keys(
        &input_key,
        &output_key,
        decomposition_base_log,
        decomposition_level_count,
        noise,
)?;
assert_eq!(
assert_eq!(
assert_eq!(cbs_private_functional_packing_keyswitch_key.input_lwe_dimension(),
input_lwe_dimension);
assert_eq!(cbs_private_functional_packing_keyswitch_key.output_glwe_dimension(),
output_glwe_dimension);
assert_eq!(cbs_private_functional_packing_keyswitch_key.key_count().0,
output_glwe_dimension.to_glwe_size().0);

unsafe fn generate_new_lwe_circuit_bootstrap_private_functional_packing_keyswitch_keys_unchecked(
    &mut self,
    input_lwe_key: &LweSecretKey32,
    output_glwe_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys32

Unsafely generate a new LWE CBSFPKSK.

impl LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeysGenerationEngine<LweSecretKey32, GlweSecretKey32, LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys32> for DefaultParallelEngine

Description:

Implementation of LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeysGenerationEngine for DefaultParallelEngine that operates on 32 bits integers.

fn generate_new_lwe_circuit_bootstrap_private_functional_packing_keyswitch_keys(
    &mut self,
    input_lwe_key: &LweSecretKey32,
    output_glwe_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> Result<LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys32, LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeysGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, LweDimension, GlweDimension,FunctionalPackingKeyswitchKeyCount
};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(10);
let output_glwe_dimension = GlweDimension(3);
let polynomial_size = PolynomialSize(256);
let decomposition_base_log = DecompositionBaseLog(3);
let decomposition_level_count = DecompositionLevelCount(5);
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut default_engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let mut default_parallel_engine =
    DefaultParallelEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let input_key: LweSecretKey32 = default_engine.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: GlweSecretKey32 = default_engine.generate_new_glwe_secret_key(output_glwe_dimension,
polynomial_size)?;

let cbs_private_functional_packing_keyswitch_key:
    LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys32 =
    default_engine
    .generate_new_lwe_circuit_bootstrap_private_functional_packing_keyswitch_keys(
        &input_key,
        &output_key,
        decomposition_base_log,
        decomposition_level_count,
        noise,
)?;
assert_eq!(
assert_eq!(
assert_eq!(cbs_private_functional_packing_keyswitch_key.input_lwe_dimension(),
input_lwe_dimension);
assert_eq!(cbs_private_functional_packing_keyswitch_key.output_glwe_dimension(),
output_glwe_dimension);
assert_eq!(cbs_private_functional_packing_keyswitch_key.key_count().0,
output_glwe_dimension.to_glwe_size().0);

unsafe fn generate_new_lwe_circuit_bootstrap_private_functional_packing_keyswitch_keys_unchecked(
    &mut self,
    input_lwe_key: &LweSecretKey32,
    output_glwe_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys32

Unsafely generate a new LWE CBSFPKSK.

impl LweKeyswitchKeyGenerationEngine<LweSecretKey32, LweSecretKey32, LweKeyswitchKey32> for DefaultEngine

Description:

Implementation of LweKeyswitchKeyGenerationEngine for DefaultEngine that operates on 32 bits integers.

fn generate_new_lwe_keyswitch_key(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &LweSecretKey32,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: Variance
) -> Result<LweKeyswitchKey32, LweKeyswitchKeyGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, LweDimension,
};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(6);
let output_lwe_dimension = LweDimension(3);
let decomposition_level_count = DecompositionLevelCount(2);
let decomposition_base_log = DecompositionBaseLog(8);
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let input_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(output_lwe_dimension)?;

let keyswitch_key = engine.generate_new_lwe_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    noise,
)?;
assert_eq!(
assert_eq!(
assert_eq!(keyswitch_key.input_lwe_dimension(), input_lwe_dimension);
assert_eq!(keyswitch_key.output_lwe_dimension(), output_lwe_dimension);

unsafe fn generate_new_lwe_keyswitch_key_unchecked(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &LweSecretKey32,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: Variance
) -> LweKeyswitchKey32

Unsafely generates a new LWE keyswitch key.

impl LwePackingKeyswitchKeyGenerationEngine<LweSecretKey32, GlweSecretKey32, LwePackingKeyswitchKey32> for DefaultEngine

Description:

Implementation of LwePackingKeyswitchKeyGenerationEngine for DefaultEngine that operates on 32 bits integers.

fn generate_new_lwe_packing_keyswitch_key(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: Variance
) -> Result<LwePackingKeyswitchKey32, LwePackingKeyswitchKeyGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, LweDimension,
};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(6);
let output_glwe_dimension = GlweDimension(3);
let output_polynomial_size = PolynomialSize(512);
let decomposition_level_count = DecompositionLevelCount(2);
let decomposition_base_log = DecompositionBaseLog(8);
let noise = Variance(2_f64.powf(-50.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let input_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: GlweSecretKey32 = engine.generate_new_glwe_secret_key(
    output_glwe_dimension,
    output_polynomial_size
)?;

let packing_keyswitch_key = engine.generate_new_lwe_packing_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    noise,
)?;
assert_eq!(
assert_eq!(
assert_eq!(packing_keyswitch_key.input_lwe_dimension(), input_lwe_dimension);
assert_eq!(packing_keyswitch_key.output_glwe_dimension(), output_glwe_dimension);
assert_eq!(packing_keyswitch_key.output_polynomial_size(), output_polynomial_size);

unsafe fn generate_new_lwe_packing_keyswitch_key_unchecked(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: Variance
) -> LwePackingKeyswitchKey32

Unsafely generates a new packing keyswitch key.

impl LwePrivateFunctionalLwePackingKeyswitchKeyGenerationEngine<LweSecretKey32, GlweSecretKey32, LwePrivateFunctionalPackingKeyswitchKey32, CleartextVector32, u32> for DefaultEngine

Description:

Implementation of LwePrivateFunctionalLwePackingKeyswitchKeyGenerationEngine for DefaultEngine that operates on 32 bits integers. Note that the function applied during keyswitching is of the form m -> m * pol for a polynomial pol. The input polynomial should be a cleartext vector containing the coefficients of pol starting with the constant term.

fn generate_new_lwe_private_functional_packing_keyswitch_key(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: StandardDev,
    f: &dyn Fn(u32) -> u32,
    polynomial: &CleartextVector32
) -> Result<LwePrivateFunctionalPackingKeyswitchKey32, LwePrivateFunctionalLwePackingKeyswitchKeyGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, LweDimension, GlweDimension
};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(10);
let output_glwe_dimension = GlweDimension(3);
let polynomial_size = PolynomialSize(256);
let decomposition_base_log = DecompositionBaseLog(3);
let decomposition_level_count = DecompositionLevelCount(5);
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let input_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: GlweSecretKey32 = engine.generate_new_glwe_secret_key(output_glwe_dimension,
polynomial_size)?;

let val = vec![1_u32; output_key.polynomial_size().0];
let polynomial: CleartextVector32 = engine.create_cleartext_vector_from(&val)?;
let private_functional_packing_keyswitch_key = engine
.generate_new_lwe_private_functional_packing_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    StandardDev(noise.get_standard_dev()),
    &|x|x,
    &polynomial,
)?;
assert_eq!(
assert_eq!(
assert_eq!(private_functional_packing_keyswitch_key.input_lwe_dimension(),
input_lwe_dimension);
assert_eq!(private_functional_packing_keyswitch_key.output_glwe_dimension(),
output_glwe_dimension);

unsafe fn generate_new_lwe_private_functional_packing_keyswitch_key_unchecked(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: StandardDev,
    f: &dyn Fn(u32) -> u32,
    polynomial: &CleartextVector32
) -> LwePrivateFunctionalPackingKeyswitchKey32

Unsafely generates a new private functional packing keyswitch key.

impl LwePublicKeyGenerationEngine<LweSecretKey32, LwePublicKey32> for DefaultEngine

Description:

Implementation of LwePublicKeyGenerationEngine for DefaultEngine that operates on 32 bits integers.

fn generate_new_lwe_public_key(
    &mut self,
    lwe_secret_key: &LweSecretKey32,
    noise: Variance,
    lwe_public_key_zero_encryption_count: LwePublicKeyZeroEncryptionCount
) -> Result<LwePublicKey32, LwePublicKeyGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, LwePublicKeyZeroEncryptionCount, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
let noise = Variance(2_f64.powf(-50.));
let lwe_public_key_zero_encryption_count = LwePublicKeyZeroEncryptionCount(42);

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_secret_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;

let public_key: LwePublicKey32 = engine.generate_new_lwe_public_key(
    &lwe_secret_key,
    noise,
    lwe_public_key_zero_encryption_count,
)?;

assert_eq!(public_key.lwe_dimension(), lwe_dimension);
assert_eq!(
    public_key.lwe_zero_encryption_count(),
    lwe_public_key_zero_encryption_count
);

unsafe fn generate_new_lwe_public_key_unchecked(
    &mut self,
    lwe_secret_key: &LweSecretKey32,
    noise: Variance,
    lwe_public_key_zero_encryption_count: LwePublicKeyZeroEncryptionCount
) -> LwePublicKey32

Unsafely generates a new LWE public key.

impl LwePublicKeyGenerationEngine<LweSecretKey32, LwePublicKey32> for DefaultParallelEngine

Description:

Implementation of LwePublicKeyGenerationEngine for DefaultParallelEngine that operates on 32 bits integers.

fn generate_new_lwe_public_key(
    &mut self,
    lwe_secret_key: &LweSecretKey32,
    noise: Variance,
    lwe_public_key_zero_encryption_count: LwePublicKeyZeroEncryptionCount
) -> Result<LwePublicKey32, LwePublicKeyGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, LwePublicKeyZeroEncryptionCount, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
let noise = Variance(2_f64.powf(-50.));
let lwe_public_key_zero_encryption_count = LwePublicKeyZeroEncryptionCount(42);

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let mut par_engine = DefaultParallelEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_secret_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;

let public_key: LwePublicKey32 = par_engine.generate_new_lwe_public_key(
    &lwe_secret_key,
    noise,
    lwe_public_key_zero_encryption_count,
)?;

assert_eq!(public_key.lwe_dimension(), lwe_dimension);
assert_eq!(
    public_key.lwe_zero_encryption_count(),
    lwe_public_key_zero_encryption_count
);

unsafe fn generate_new_lwe_public_key_unchecked(
    &mut self,
    lwe_secret_key: &LweSecretKey32,
    noise: Variance,
    lwe_public_key_zero_encryption_count: LwePublicKeyZeroEncryptionCount
) -> LwePublicKey32

Unsafely generates a new LWE public key.

impl LweSecretKeyEntity for LweSecretKey32

fn lwe_dimension(&self) -> LweDimension

Returns the LWE dimension of the key.

impl LweSecretKeyGenerationEngine<LweSecretKey32> for DefaultEngine

Description:

Implementation of LweSecretKeyGenerationEngine for DefaultEngine that operates on 32 bits integers.

fn generate_new_lwe_secret_key(
    &mut self,
    lwe_dimension: LweDimension
) -> Result<LweSecretKey32, LweSecretKeyGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_secret_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
assert_eq!(lwe_secret_key.lwe_dimension(), lwe_dimension);

unsafe fn generate_new_lwe_secret_key_unchecked(
    &mut self,
    lwe_dimension: LweDimension
) -> LweSecretKey32

Unsafely generates a new LWE secret key.

impl LweSeededBootstrapKeyGenerationEngine<LweSecretKey32, GlweSecretKey32, LweSeededBootstrapKey32> for DefaultEngine

Description:

Implementation of LweSeededBootstrapKeyGenerationEngine for DefaultEngine that operates on 32 bits integers. It outputs a seeded bootstrap key in the standard domain.

fn generate_new_lwe_seeded_bootstrap_key(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> Result<LweSeededBootstrapKey32, LweSeededBootstrapKeyGenerationError<Self::EngineError>>

Example

use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, GlweDimension, LweDimension, PolynomialSize,
    Variance, *,
};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let (lwe_dim, glwe_dim, poly_size) = (LweDimension(4), GlweDimension(6), PolynomialSize(256));
let (dec_lc, dec_bl) = (DecompositionLevelCount(3), DecompositionBaseLog(5));
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_sk: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey32 = engine.generate_new_glwe_secret_key(glwe_dim, poly_size)?;

let bsk: LweSeededBootstrapKey32 =
    engine.generate_new_lwe_seeded_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;
assert_eq!(bsk.glwe_dimension(), glwe_dim);
assert_eq!(bsk.polynomial_size(), poly_size);
assert_eq!(bsk.input_lwe_dimension(), lwe_dim);
assert_eq!(bsk.decomposition_base_log(), dec_bl);
assert_eq!(bsk.decomposition_level_count(), dec_lc);

unsafe fn generate_new_lwe_seeded_bootstrap_key_unchecked(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> LweSeededBootstrapKey32

Unsafely generates a new seeded LWE bootstrap key.

impl LweSeededBootstrapKeyGenerationEngine<LweSecretKey32, GlweSecretKey32, LweSeededBootstrapKey32> for DefaultParallelEngine

Description:

Implementation of LweSeededBootstrapKeyGenerationEngine for DefaultParallelEngine that operates on 32 bits integers. It outputs a seeded bootstrap key in the standard domain.

fn generate_new_lwe_seeded_bootstrap_key(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> Result<LweSeededBootstrapKey32, LweSeededBootstrapKeyGenerationError<Self::EngineError>>

Example

use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, GlweDimension, LweDimension, PolynomialSize,
    Variance, *,
};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let (lwe_dim, glwe_dim, poly_size) = (LweDimension(4), GlweDimension(6), PolynomialSize(256));
let (dec_lc, dec_bl) = (DecompositionLevelCount(3), DecompositionBaseLog(5));
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut default_engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let mut default_parallel_engine =
    DefaultParallelEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let lwe_sk: LweSecretKey32 = default_engine.generate_new_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey32 =
    default_engine.generate_new_glwe_secret_key(glwe_dim, poly_size)?;

let bsk: LweSeededBootstrapKey32 = default_parallel_engine
    .generate_new_lwe_seeded_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;
assert_eq!(bsk.glwe_dimension(), glwe_dim);
assert_eq!(bsk.polynomial_size(), poly_size);
assert_eq!(bsk.input_lwe_dimension(), lwe_dim);
assert_eq!(bsk.decomposition_base_log(), dec_bl);
assert_eq!(bsk.decomposition_level_count(), dec_lc);

unsafe fn generate_new_lwe_seeded_bootstrap_key_unchecked(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &GlweSecretKey32,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> LweSeededBootstrapKey32

Unsafely generates a new seeded LWE bootstrap key.

impl LweSeededCiphertextEncryptionEngine<LweSecretKey32, Plaintext32, LweSeededCiphertext32> for DefaultEngine

Description:

Implementation of LweSeededCiphertextEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn encrypt_lwe_seeded_ciphertext(
    &mut self,
    key: &LweSecretKey32,
    input: &Plaintext32,
    noise: Variance
) -> Result<LweSeededCiphertext32, LweSeededCiphertextEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweDimension, Variance, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = 3_u32 << 20;
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let ciphertext = engine.encrypt_lwe_seeded_ciphertext(&key, &plaintext, noise)?;
assert_eq!(ciphertext.lwe_dimension(), lwe_dimension);

unsafe fn encrypt_lwe_seeded_ciphertext_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &Plaintext32,
    noise: Variance
) -> LweSeededCiphertext32

Unsafely encrypts a seeded LWE ciphertext.

impl LweSeededCiphertextVectorEncryptionEngine<LweSecretKey32, PlaintextVector32, LweSeededCiphertextVector32> for DefaultEngine

Description:

Implementation of LweSeededCiphertextVectorEncryptionEngine for DefaultEngine that operates on 32 bits integers.

fn encrypt_lwe_seeded_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<LweSeededCiphertextVector32, LweSeededCiphertextVectorEncryptionError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{LweCiphertextCount, LweDimension};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 3];
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector_from(&input)?;

let mut ciphertext_vector: LweSeededCiphertextVector32 =
    engine.encrypt_lwe_seeded_ciphertext_vector(&key, &plaintext_vector, noise)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(

unsafe fn encrypt_lwe_seeded_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> LweSeededCiphertextVector32

Unsafely encrypts a seeded LWE ciphertext vector.

impl LweSeededKeyswitchKeyGenerationEngine<LweSecretKey32, LweSecretKey32, LweSeededKeyswitchKey32> for DefaultEngine

fn generate_new_lwe_seeded_keyswitch_key(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &LweSecretKey32,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: Variance
) -> Result<LweSeededKeyswitchKey32, LweSeededKeyswitchKeyGenerationError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::{
    DecompositionBaseLog, DecompositionLevelCount, LweDimension,
};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(6);
let output_lwe_dimension = LweDimension(3);
let decomposition_level_count = DecompositionLevelCount(2);
let decomposition_base_log = DecompositionBaseLog(8);
let noise = Variance(2_f64.powf(-25.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let input_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(output_lwe_dimension)?;

let seeded_keyswitch_key = engine.generate_new_lwe_seeded_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    noise,
)?;
assert_eq!(
assert_eq!(
assert_eq!(seeded_keyswitch_key.input_lwe_dimension(), input_lwe_dimension);
assert_eq!(seeded_keyswitch_key.output_lwe_dimension(), output_lwe_dimension);

unsafe fn generate_new_lwe_seeded_keyswitch_key_unchecked(
    &mut self,
    input_key: &LweSecretKey32,
    output_key: &LweSecretKey32,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: Variance
) -> LweSeededKeyswitchKey32

Unsafely generates a new seeded LWE keyswitch key.

impl LweToGlweSecretKeyTransformationEngine<LweSecretKey32, GlweSecretKey32> for DefaultEngine

fn transform_lwe_secret_key_to_glwe_secret_key(
    &mut self,
    lwe_secret_key: LweSecretKey32,
    polynomial_size: PolynomialSize
) -> Result<GlweSecretKey32, LweToGlweSecretKeyTransformationError<Self::EngineError>>

Example

use concrete_core::prelude::{GlweDimension, LweDimension, PolynomialSize, *};

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(8);
let polynomial_size = PolynomialSize(4);

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;

let lwe_secret_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
assert_eq!(lwe_secret_key.lwe_dimension(), lwe_dimension);

let glwe_secret_key =
    engine.transform_lwe_secret_key_to_glwe_secret_key(lwe_secret_key, polynomial_size)?;
assert_eq!(glwe_secret_key.glwe_dimension(), GlweDimension(2));
assert_eq!(glwe_secret_key.polynomial_size(), polynomial_size);

unsafe fn transform_lwe_secret_key_to_glwe_secret_key_unchecked(
    &mut self,
    lwe_secret_key: LweSecretKey32,
    polynomial_size: PolynomialSize
) -> GlweSecretKey32

Unsafely transforms an LWE secret key into a GLWE secret key

impl PartialEq<LweSecretKey32> for LweSecretKey32

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for LweSecretKey32

impl StructuralEq for LweSecretKey32

impl StructuralPartialEq for LweSecretKey32