Struct concrete_core::backends::core::entities::LweBootstrapKey64

pub struct LweBootstrapKey64(_);

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

Trait Implementations

impl AbstractEntity for LweBootstrapKey64

type Kind = LweBootstrapKeyKind

The kind of the entity.

impl Clone for LweBootstrapKey64

fn clone(&self) -> LweBootstrapKey64

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LweBootstrapKey64

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

Formats the value using the given formatter.

impl DestructionEngine<LweBootstrapKey64> for CoreEngine

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

Destroys an entity.

unsafe fn destroy_unchecked(&mut self, _entity: LweBootstrapKey64)

Unsafely destroys an entity.

impl LweBootstrapKeyConversionEngine<LweBootstrapKey64, FourierLweBootstrapKey64> for CoreEngine

Description:

Implementation of LweBootstrapKeyConversionEngine for CoreEngine that operates on 64 bits integers. It converts a bootstrap key from the standard to the Fourier domain.

fn convert_lwe_bootstrap_key(
    &mut self,
    input: &LweBootstrapKey64
) -> Result<FourierLweBootstrapKey64, LweBootstrapKeyConversionError<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: LweSecretKey64 = engine.create_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dim, poly_size)?;
let bsk: LweBootstrapKey64 =
    engine.create_lwe_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;

let fourier_bsk: FourierLweBootstrapKey64 = 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);

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

unsafe fn convert_lwe_bootstrap_key_unchecked(
    &mut self,
    input: &LweBootstrapKey64
) -> FourierLweBootstrapKey64

Unsafely converts an LWE bootstrap key.

impl LweBootstrapKeyCreationEngine<LweSecretKey64, GlweSecretKey64, LweBootstrapKey64> for CoreEngine

Description:

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

fn create_lwe_bootstrap_key(
    &mut self,
    input_key: &LweSecretKey64,
    output_key: &GlweSecretKey64,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> Result<LweBootstrapKey64, 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: LweSecretKey64 = engine.create_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dim, poly_size)?;

let bsk: LweBootstrapKey64 =
    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: &LweSecretKey64,
    output_key: &GlweSecretKey64,
    decomposition_base_log: DecompositionBaseLog,
    decomposition_level_count: DecompositionLevelCount,
    noise: Variance
) -> LweBootstrapKey64

Unsafely creates an LWE bootstrap key.

impl LweBootstrapKeyEntity for LweBootstrapKey64

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 output_lwe_dimension(&self) -> LweDimension

Returns the output LWE dimension of the key.

impl PartialEq<LweBootstrapKey64> for LweBootstrapKey64

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

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

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

This method tests for !=.

impl StructuralPartialEq for LweBootstrapKey64