Struct concrete_core::backends::default::entities::LweBootstrapKey32

pub struct LweBootstrapKey32(_);

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

Trait Implementations

impl AbstractEntity for LweBootstrapKey32

type Kind = LweBootstrapKeyKind

The kind of the entity.

impl Clone for LweBootstrapKey32

fn clone(&self) -> LweBootstrapKey32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LweBootstrapKey32

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

Formats the value using the given formatter.

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

Description:

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

fn deserialize(
    &mut self,
    serialized: &[u8]
) -> Result<LweBootstrapKey32, EntityDeserializationError<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)?;

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

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

Unsafely deserializes an entity.

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

Description:

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

fn serialize(
    &mut self,
    entity: &LweBootstrapKey32
) -> Result<Vec<u8>, EntitySerializationError<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)?;

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

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

Unsafely serializes an entity.

impl LweBootstrapKeyConsumingRetrievalEngine<LweBootstrapKey32, Vec<u32, Global>> for DefaultEngine

fn consume_retrieve_lwe_bootstrap_key(
    &mut self,
    bootstrap_key: LweBootstrapKey32
) -> Result<Vec<u32>, LweBootstrapKeyConsumingRetrievalError<Self::EngineError>>

Example:

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

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
let glwe_size = GlweSize(2);
let polynomial_size = PolynomialSize(256);
let level = DecompositionLevelCount(2);
let base_log = DecompositionBaseLog(1);

// 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 owned_container =
    vec![0_u32; lwe_dimension.0 * level.0 * glwe_size.0 * glwe_size.0 * polynomial_size.0];
let original_vec_ptr = owned_container.as_ptr();

let lwe_bootstrap_key: LweBootstrapKey32 = engine.create_lwe_bootstrap_key_from(
    owned_container,
    glwe_size,
    polynomial_size,
    base_log,
    level,
)?;
let retrieved_container = engine.consume_retrieve_lwe_bootstrap_key(lwe_bootstrap_key)?;
assert_eq!(original_vec_ptr, retrieved_container.as_ptr());

unsafe fn consume_retrieve_lwe_bootstrap_key_unchecked(
    &mut self,
    bootstrap_key: LweBootstrapKey32
) -> Vec<u32>

Unsafely retrieves the content of the container from an LWE bootstrap key, consuming it in the process.

impl LweBootstrapKeyConversionEngine<LweBootstrapKey32, FftFourierLweBootstrapKey32> for FftEngine

Description

Implementation of LweBootstrapKeyConversionEngine for FftEngine that operates on 32 bit integers. It converts a bootstrap key from the standard to the Fourier domain.

fn convert_lwe_bootstrap_key(
    &mut self,
    input: &LweBootstrapKey32
) -> Result<FftFourierLweBootstrapKey32, LweBootstrapKeyConversionError<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 fft_engine = FftEngine::new(())?;
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_engine.generate_new_lwe_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;

let fourier_bsk: FftFourierLweBootstrapKey32 = fft_engine.convert_lwe_bootstrap_key(&bsk)?;
assert_eq!(fourier_bsk.glwe_dimension(), glwe_dim);
assert_eq!(fourier_bsk.polynomial_size(), poly_size);
assert_eq!(fourier_bsk.input_lwe_dimension(), lwe_dim);
assert_eq!(fourier_bsk.decomposition_base_log(), dec_bl);
assert_eq!(fourier_bsk.decomposition_level_count(), dec_lc);

unsafe fn convert_lwe_bootstrap_key_unchecked(
    &mut self,
    input: &LweBootstrapKey32
) -> FftFourierLweBootstrapKey32

Unsafely converts an LWE bootstrap key.

impl LweBootstrapKeyCreationEngine<Vec<u32, Global>, LweBootstrapKey32> for DefaultEngine

fn create_lwe_bootstrap_key_from(
    &mut self,
    container: Vec<u32>,
    glwe_size: GlweSize,
    poly_size: PolynomialSize,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount
) -> Result<LweBootstrapKey32, LweBootstrapKeyCreationError<Self::EngineError>>

Example:

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

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
let glwe_size = GlweSize(2);
let polynomial_size = PolynomialSize(256);
let level = DecompositionLevelCount(2);
let base_log = DecompositionBaseLog(1);

// 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 owned_container =
    vec![0_u32; lwe_dimension.0 * level.0 * glwe_size.0 * glwe_size.0 * polynomial_size.0];

let lwe_bootstrap_key: LweBootstrapKey32 = engine.create_lwe_bootstrap_key_from(
    owned_container,
    glwe_size,
    polynomial_size,
    base_log,
    level,
)?;

unsafe fn create_lwe_bootstrap_key_from_unchecked(
    &mut self,
    container: Vec<u32>,
    glwe_size: GlweSize,
    poly_size: PolynomialSize,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount
) -> LweBootstrapKey32

Unsafely creates an LWE bootstrap key from an existing container.

impl LweBootstrapKeyDiscardingConversionEngine<LweBootstrapKey32, LweBootstrapKeyMutView32<'_>> for DefaultEngine

fn discard_convert_lwe_bootstrap_key(
    &mut self,
    output: &mut LweBootstrapKeyMutView32<'_>,
    input: &LweBootstrapKey32
) -> Result<(), LweBootstrapKeyDiscardingConversionError<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 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_engine.generate_new_lwe_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;

let mut owned_container = vec![
    0_u32;
    lwe_dim.0
        * dec_lc.0
        * glwe_dim.to_glwe_size().0
        * glwe_dim.to_glwe_size().0
        * poly_size.0
];

let mut out_bsk_mut_view: LweBootstrapKeyMutView32 = default_engine
    .create_lwe_bootstrap_key_from(
        owned_container.as_mut_slice(),
        glwe_dim.to_glwe_size(),
        poly_size,
        dec_bl,
        dec_lc,
    )?;

default_engine.discard_convert_lwe_bootstrap_key(&mut out_bsk_mut_view, &bsk)?;
assert_eq!(out_bsk_mut_view.glwe_dimension(), glwe_dim);
assert_eq!(out_bsk_mut_view.polynomial_size(), poly_size);
assert_eq!(out_bsk_mut_view.input_lwe_dimension(), lwe_dim);
assert_eq!(out_bsk_mut_view.decomposition_base_log(), dec_bl);
assert_eq!(out_bsk_mut_view.decomposition_level_count(), dec_lc);

// Check content is the same

let original_bsk_container = default_engine.consume_retrieve_lwe_bootstrap_key(bsk)?;
let mut_view_bsk_container =
    default_engine.consume_retrieve_lwe_bootstrap_key(out_bsk_mut_view)?;

assert_eq!(original_bsk_container, mut_view_bsk_container);

unsafe fn discard_convert_lwe_bootstrap_key_unchecked(
    &mut self,
    output: &mut LweBootstrapKeyMutView32<'_>,
    input: &LweBootstrapKey32
)

Unsafely converts a LWE bootstrap key .

impl LweBootstrapKeyEntity for LweBootstrapKey32

fn glwe_dimension(&self) -> GlweDimension

Returns the GLWE dimension of the key.

fn polynomial_size(&self) -> PolynomialSize

Returns the polynomial size of the key.

fn input_lwe_dimension(&self) -> LweDimension

Returns the input LWE dimension of the key.

fn decomposition_base_log(&self) -> DecompositionBaseLog

Returns the number of decomposition levels of the key.

fn decomposition_level_count(&self) -> DecompositionLevelCount

Returns the logarithm of the base used in the key.

fn output_lwe_dimension(&self) -> LweDimension

Returns the output LWE dimension of the 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 LweSeededBootstrapKeyToLweBootstrapKeyTransformationEngine<LweSeededBootstrapKey32, LweBootstrapKey32> for DefaultEngine

Description:

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

fn transform_lwe_seeded_bootstrap_key_to_lwe_bootstrap_key(
    &mut self,
    lwe_seeded_bootstrap_key: LweSeededBootstrapKey32
) -> Result<LweBootstrapKey32, LweSeededBootstrapKeyToLweBootstrapKeyTransformationError<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 seeded_bsk: LweSeededBootstrapKey32 =
    engine.generate_new_lwe_seeded_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;

let bsk = engine.transform_lwe_seeded_bootstrap_key_to_lwe_bootstrap_key(seeded_bsk)?;

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 transform_lwe_seeded_bootstrap_key_to_lwe_bootstrap_key_unchecked(
    &mut self,
    lwe_seeded_bootstrap_key: LweSeededBootstrapKey32
) -> LweBootstrapKey32

Unsafely transforms an LWE seeded bootstrap key into an LWE bootstrap key

impl PartialEq<LweBootstrapKey32> for LweBootstrapKey32

fn eq(&self, other: &LweBootstrapKey32) -> 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 LweBootstrapKey32

impl StructuralEq for LweBootstrapKey32

impl StructuralPartialEq for LweBootstrapKey32