Struct concrete_core::backends::default::entities::LweSeededBootstrapKey64

pub struct LweSeededBootstrapKey64(_);

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

Trait Implementations

impl AbstractEntity for LweSeededBootstrapKey64

type Kind = LweSeededBootstrapKeyKind

The kind of the entity.

impl Clone for LweSeededBootstrapKey64

fn clone(&self) -> LweSeededBootstrapKey64

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LweSeededBootstrapKey64

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

Formats the value using the given formatter.

impl DestructionEngine<LweSeededBootstrapKey64> for DefaultEngine

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

Destroys an entity.

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

Unsafely destroys an entity.

impl LweSeededBootstrapKeyCreationEngine<LweSecretKey64, GlweSecretKey64, LweSeededBootstrapKey64> for DefaultEngine

Description:

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

fn create_lwe_seeded_bootstrap_key(
    &mut self,
    input_key: &LweSecretKey64,
    output_key: &GlweSecretKey64,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> Result<LweSeededBootstrapKey64, LweSeededBootstrapKeyCreationError<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.));

// 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: LweSecretKey64 = engine.create_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dim, poly_size)?;

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

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

unsafe fn create_lwe_seeded_bootstrap_key_unchecked(
    &mut self,
    input_key: &LweSecretKey64,
    output_key: &GlweSecretKey64,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> LweSeededBootstrapKey64

Unsafely creates a seeded LWE bootstrap key.

impl LweSeededBootstrapKeyEntity for LweSeededBootstrapKey64

type InputKeyDistribution = BinaryKeyDistribution

The distribution of key the input ciphertext is encrypted with.

type OutputKeyDistribution = BinaryKeyDistribution

The distribution of the key the output ciphertext is encrypted with.

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 compression_seed(&self) -> CompressionSeed

Returns the compression seed used to generate the seeded LWE bootstrap key during encryption.

fn output_lwe_dimension(&self) -> LweDimension

Returns the output LWE dimension of the key.

impl LweSeededBootstrapKeyToLweBootstrapKeyTransformationEngine<LweSeededBootstrapKey64, LweBootstrapKey64> for DefaultEngine

Description:

Implementation of LweSeededBootstrapKeyToLweBootstrapKeyTransformationEngine for DefaultEngine that operates on 64 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: LweSeededBootstrapKey64
) -> Result<LweBootstrapKey64, LweSeededBootstrapKeyToLweBootstrapKeyTransformationEngineError<Self::EngineError>>

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

// 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: LweSecretKey64 = engine.create_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dim, poly_size)?;

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

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

unsafe fn transform_lwe_seeded_bootstrap_key_to_lwe_bootstrap_key_unchecked(
    &mut self,
    lwe_seeded_bootstrap_key: LweSeededBootstrapKey64
) -> LweBootstrapKey64

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

impl PartialEq<LweSeededBootstrapKey64> for LweSeededBootstrapKey64

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

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

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

This method tests for !=.

impl Eq for LweSeededBootstrapKey64

impl StructuralEq for LweSeededBootstrapKey64

impl StructuralPartialEq for LweSeededBootstrapKey64