Struct concrete_core::backends::core::entities::GlweSecretKey32

pub struct GlweSecretKey32(_);

A structure representing a GLWE secret key with 32 bits of precision.

Trait Implementations

impl AbstractEntity for GlweSecretKey32

type Kind = GlweSecretKeyKind

The kind of the entity.

impl Clone for GlweSecretKey32

fn clone(&self) -> GlweSecretKey32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GlweSecretKey32

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GlweSecretKey32

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl DestructionEngine<GlweSecretKey32> for CoreEngine

fn destroy(
    &mut self,
    entity: GlweSecretKey32
) -> Result<(), DestructionError<Self::EngineError>>

Destroys an entity.

unsafe fn destroy_unchecked(&mut self, entity: GlweSecretKey32)

Unsafely destroys an entity.

impl GlweCiphertextDecryptionEngine<GlweSecretKey32, GlweCiphertext32, PlaintextVector32> for CoreEngine

Description:

Implementation of GlweCiphertextDecryptionEngine for CoreEngine that operates on 32 bits integers.

fn decrypt_glwe_ciphertext(
    &mut self,
    key: &GlweSecretKey32,
    input: &GlweCiphertext32
) -> Result<PlaintextVector32, GlweCiphertextDecryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let key: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext = engine.encrypt_glwe_ciphertext(&key, &plaintext_vector, noise)?;

let decrypted_plaintext_vector = engine.decrypt_glwe_ciphertext(&key, &ciphertext)?;
assert_eq!(

engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext)?;
engine.destroy(decrypted_plaintext_vector)?;

unsafe fn decrypt_glwe_ciphertext_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    input: &GlweCiphertext32
) -> PlaintextVector32

Unsafely decrypts a GLWE ciphertext into a plaintext vector.

impl GlweCiphertextDiscardingDecryptionEngine<GlweSecretKey32, GlweCiphertext32, PlaintextVector32> for CoreEngine

Description:

Implementation of GlweCiphertextDiscardingDecryptionEngine for CoreEngine that operates on 32 bits integers.

fn discard_decrypt_glwe_ciphertext(
    &mut self,
    key: &GlweSecretKey32,
    output: &mut PlaintextVector32,
    input: &GlweCiphertext32
) -> Result<(), GlweCiphertextDiscardingDecryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PlaintextCount, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let key: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let mut plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext = engine.encrypt_glwe_ciphertext(&key, &plaintext_vector, noise)?;

engine.discard_decrypt_glwe_ciphertext(&key, &mut plaintext_vector, &ciphertext)?;
assert_eq!(plaintext_vector.plaintext_count(), PlaintextCount(4));

engine.destroy(ciphertext)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key)?;

unsafe fn discard_decrypt_glwe_ciphertext_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    output: &mut PlaintextVector32,
    input: &GlweCiphertext32
)

Unsafely decrypts a GLWE ciphertext .

impl GlweCiphertextDiscardingEncryptionEngine<GlweSecretKey32, PlaintextVector32, GlweCiphertext32> for CoreEngine

Description:

Implementation of GlweCiphertextDiscardingEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn discard_encrypt_glwe_ciphertext(
    &mut self,
    key: &GlweSecretKey32,
    output: &mut GlweCiphertext32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<(), GlweCiphertextDiscardingEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let key_1: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let mut ciphertext = engine.encrypt_glwe_ciphertext(&key_1, &plaintext_vector, noise)?;
// We're going to re-encrypt the input with another secret key
// For this, it is required that the second secret key uses the same GLWE dimension
// and polynomial size as the first one.
let key_2: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;

engine.discard_encrypt_glwe_ciphertext(&key_2, &mut ciphertext, &plaintext_vector, noise)?;
assert_eq!(ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext.polynomial_size(), polynomial_size);

engine.destroy(ciphertext)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key_1)?;
engine.destroy(key_2)?;

unsafe fn discard_encrypt_glwe_ciphertext_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    output: &mut GlweCiphertext32,
    input: &PlaintextVector32,
    noise: Variance
)

Unsafely encrypts a GLWE ciphertext .

impl GlweCiphertextEncryptionEngine<GlweSecretKey32, PlaintextVector32, GlweCiphertext32> for CoreEngine

Description:

Implementation of GlweCiphertextEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn encrypt_glwe_ciphertext(
    &mut self,
    key: &GlweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<GlweCiphertext32, GlweCiphertextEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// There are always polynomial_size messages encrypted in the GLWE ciphertext
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; polynomial_size.0];
let noise = Variance(2_f64.powf(-25.));

let mut engine = CoreEngine::new()?;
let key: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;

let ciphertext = engine.encrypt_glwe_ciphertext(&key, &plaintext_vector, noise)?;
assert_eq!(ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext.polynomial_size(), polynomial_size);

engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext)?;

unsafe fn encrypt_glwe_ciphertext_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> GlweCiphertext32

Unsafely encrypts a plaintext vector into a GLWE ciphertext.

impl GlweCiphertextVectorDecryptionEngine<GlweSecretKey32, GlweCiphertextVector32, PlaintextVector32> for CoreEngine

Description:

Implementation of GlweCiphertextVectorDecryptionEngine for CoreEngine that operates on 32 bits integers.

fn decrypt_glwe_ciphertext_vector(
    &mut self,
    key: &GlweSecretKey32,
    input: &GlweCiphertextVector32
) -> Result<PlaintextVector32, GlweCiphertextVectorDecryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PlaintextCount, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let key: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext_vector =
    engine.encrypt_glwe_ciphertext_vector(&key, &plaintext_vector, noise)?;

let decrypted_plaintext_vector =
    engine.decrypt_glwe_ciphertext_vector(&key, &ciphertext_vector)?;
assert_eq!(

engine.destroy(ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(decrypted_plaintext_vector)?;
engine.destroy(key)?;

unsafe fn decrypt_glwe_ciphertext_vector_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    input: &GlweCiphertextVector32
) -> PlaintextVector32

Unsafely decrypts a GLWE ciphertext vector.

impl GlweCiphertextVectorDiscardingDecryptionEngine<GlweSecretKey32, GlweCiphertextVector32, PlaintextVector32> for CoreEngine

Description:

Implementation of GlweCiphertextVectorDiscardingDecryptionEngine for CoreEngine that operates on 32 bits integers.

fn discard_decrypt_glwe_ciphertext_vector(
    &mut self,
    key: &GlweSecretKey32,
    output: &mut PlaintextVector32,
    input: &GlweCiphertextVector32
) -> Result<(), GlweCiphertextVectorDiscardingDecryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PlaintextCount, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let key: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let mut plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext_vector =
    engine.encrypt_glwe_ciphertext_vector(&key, &plaintext_vector, noise)?;

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

engine.destroy(ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key)?;

unsafe fn discard_decrypt_glwe_ciphertext_vector_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    output: &mut PlaintextVector32,
    input: &GlweCiphertextVector32
)

Unsafely encrypts a GLWE ciphertext vector .

impl GlweCiphertextVectorDiscardingEncryptionEngine<GlweSecretKey32, PlaintextVector32, GlweCiphertextVector32> for CoreEngine

Description:

Implementation of GlweCiphertextVectorDiscardingEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn discard_encrypt_glwe_ciphertext_vector(
    &mut self,
    key: &GlweSecretKey32,
    output: &mut GlweCiphertextVector32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<(), GlweCiphertextVectorDiscardingEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweCiphertextCount, GlweDimension, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let key_1: GlweSecretKey32 =
    engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let key_2: GlweSecretKey32 =
    engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let mut ciphertext_vector =
    engine.encrypt_glwe_ciphertext_vector(&key_1, &plaintext_vector, noise)?;

engine.discard_encrypt_glwe_ciphertext_vector(
    &key_2,
    &mut ciphertext_vector,
    &plaintext_vector,
    noise,
)?;
assert_eq!(ciphertext_vector.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext_vector.polynomial_size(), polynomial_size);
assert_eq!(

engine.destroy(ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key_1)?;
engine.destroy(key_2)?;

unsafe fn discard_encrypt_glwe_ciphertext_vector_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    output: &mut GlweCiphertextVector32,
    input: &PlaintextVector32,
    noise: Variance
)

Unsafely encrypts a GLWE ciphertext vector .

impl GlweCiphertextVectorEncryptionEngine<GlweSecretKey32, PlaintextVector32, GlweCiphertextVector32> for CoreEngine

Description:

Implementation of GlweCiphertextVectorEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn encrypt_glwe_ciphertext_vector(
    &mut self,
    key: &GlweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<GlweCiphertextVector32, GlweCiphertextVectorEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweCiphertextCount, GlweDimension, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let key: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;

let ciphertext_vector =
    engine.encrypt_glwe_ciphertext_vector(&key, &plaintext_vector, noise)?;
assert_eq!(
assert_eq!(ciphertext_vector.polynomial_size(), polynomial_size);
assert_eq!(ciphertext_vector.glwe_dimension(), glwe_dimension);

engine.destroy(ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key)?;

unsafe fn encrypt_glwe_ciphertext_vector_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> GlweCiphertextVector32

Unsafely encrypts a GLWE ciphertext vector.

impl GlweCiphertextVectorZeroEncryptionEngine<GlweSecretKey32, GlweCiphertextVector32> for CoreEngine

Description:

Implementation of GlweCiphertextVectorZeroEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn zero_encrypt_glwe_ciphertext_vector(
    &mut self,
    key: &GlweSecretKey32,
    noise: Variance,
    count: GlweCiphertextCount
) -> Result<GlweCiphertextVector32, GlweCiphertextVectorZeroEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweCiphertextCount, GlweDimension, PolynomialSize};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(1024);
let ciphertext_count = GlweCiphertextCount(3);
let noise = Variance(2_f64.powf(-25.));

let mut engine = CoreEngine::new()?;
let key: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;

let ciphertext_vector =
    engine.zero_encrypt_glwe_ciphertext_vector(&key, noise, ciphertext_count)?;
assert_eq!(ciphertext_vector.glwe_ciphertext_count(), ciphertext_count);
assert_eq!(ciphertext_vector.polynomial_size(), polynomial_size);
assert_eq!(ciphertext_vector.glwe_dimension(), glwe_dimension);

engine.destroy(ciphertext_vector)?;
engine.destroy(key)?;

unsafe fn zero_encrypt_glwe_ciphertext_vector_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    noise: Variance,
    count: GlweCiphertextCount
) -> GlweCiphertextVector32

Unsafely encrypts zero in a GLWE ciphertext vector.

impl GlweCiphertextZeroEncryptionEngine<GlweSecretKey32, GlweCiphertext32> for CoreEngine

Description:

Implementation of GlweCiphertextZeroEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn zero_encrypt_glwe_ciphertext(
    &mut self,
    key: &GlweSecretKey32,
    noise: Variance
) -> Result<GlweCiphertext32, GlweCiphertextZeroEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let key: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;

let ciphertext = engine.zero_encrypt_glwe_ciphertext(&key, noise)?;
assert_eq!(ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext.polynomial_size(), polynomial_size);

engine.destroy(key)?;
engine.destroy(ciphertext)?;

unsafe fn zero_encrypt_glwe_ciphertext_unchecked(
    &mut self,
    key: &GlweSecretKey32,
    noise: Variance
) -> GlweCiphertext32

Unsafely encrypts a zero in a GLWE ciphertext.

impl GlweSecretKeyCreationEngine<GlweSecretKey32> for CoreEngine

Description:

Implementation of GlweSecretKeyCreationEngine for CoreEngine that operates on 32 bits integers.

fn create_glwe_secret_key(
    &mut self,
    glwe_dimension: GlweDimension,
    polynomial_size: PolynomialSize
) -> Result<GlweSecretKey32, GlweSecretKeyCreationError<Self::EngineError>>

Example:

use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;

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

let mut engine = CoreEngine::new()?;
let glwe_secret_key: GlweSecretKey32 =
    engine.create_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);

engine.destroy(glwe_secret_key)?;

unsafe fn create_glwe_secret_key_unchecked(
    &mut self,
    glwe_dimension: GlweDimension,
    polynomial_size: PolynomialSize
) -> GlweSecretKey32

Unsafely creates a new GLWE secret key.

impl GlweSecretKeyEntity for GlweSecretKey32

type KeyDistribution = BinaryKeyDistribution

The distribution of this key.

fn glwe_dimension(&self) -> GlweDimension

Returns the GLWE dimension of the key.

fn polynomial_size(&self) -> PolynomialSize

Returns the polynomial size of the key.

impl GlweToLweSecretKeyTransmutationEngine<GlweSecretKey32, LweSecretKey32> for CoreEngine

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

Example

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

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

let mut engine = CoreEngine::new()?;

let glwe_secret_key: GlweSecretKey32 =
    engine.create_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.transmute_glwe_secret_key_to_lwe_secret_key(glwe_secret_key)?;
assert_eq!(lwe_secret_key.lwe_dimension(), LweDimension(8));

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

Unsafely transmutes a GLWE secret key into a lwe secret key

impl LweBootstrapKeyCreationEngine<LweSecretKey32, GlweSecretKey32, FourierLweBootstrapKey32> for CoreEngine

Description:

Implementation of LweBootstrapKeyCreationEngine for CoreEngine that operates on 32 bits integers. It outputs a bootstrap key in the Fourier domain.

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

Example

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

// 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.));

let mut engine = CoreEngine::new()?;
let lwe_sk: LweSecretKey32 = engine.create_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dim, poly_size)?;

let bsk: FourierLweBootstrapKey32 =
    engine.create_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);

engine.destroy(lwe_sk)?;
engine.destroy(glwe_sk)?;
engine.destroy(bsk)?;

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

Unsafely creates an LWE bootstrap key.

impl LweBootstrapKeyCreationEngine<LweSecretKey32, GlweSecretKey32, LweBootstrapKey32> for CoreEngine

Description:

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

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

Example

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

// 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.));

let mut engine = CoreEngine::new()?;
let lwe_sk: LweSecretKey32 = engine.create_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey32 = engine.create_glwe_secret_key(glwe_dim, poly_size)?;

let bsk: LweBootstrapKey32 =
    engine.create_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);

engine.destroy(lwe_sk)?;
engine.destroy(glwe_sk)?;
engine.destroy(bsk)?;

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

Unsafely creates an LWE bootstrap key.

impl PartialEq<GlweSecretKey32> for GlweSecretKey32

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

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

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

This method tests for !=.

impl Serialize for GlweSecretKey32

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 GlweSecretKey32