Struct concrete_core::backends::default::entities::LweKeyswitchKey64

pub struct LweKeyswitchKey64(_);

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

Trait Implementations

impl AbstractEntity for LweKeyswitchKey64

type Kind = LweKeyswitchKeyKind

The kind of the entity.

impl Clone for LweKeyswitchKey64

fn clone(&self) -> LweKeyswitchKey64

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LweKeyswitchKey64

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

Formats the value using the given formatter.

impl DestructionEngine<LweKeyswitchKey64> for DefaultEngine

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

Destroys an entity.

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

Unsafely destroys an entity.

impl LweCiphertextDiscardingKeyswitchEngine<LweKeyswitchKey64, LweCiphertext64, LweCiphertext64> for DefaultEngine

Description:

Implementation of LweCiphertextDiscardingKeyswitchEngine for DefaultEngine that operates on 64 bits integers.

fn discard_keyswitch_lwe_ciphertext(
    &mut self,
    output: &mut LweCiphertext64,
    input: &LweCiphertext64,
    ksk: &LweKeyswitchKey64
) -> Result<(), LweCiphertextDiscardingKeyswitchError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{
    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.));
// Here a hard-set encoding is applied (shift by 50 bits)
let input = 3_u64 << 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: LweSecretKey64 = engine.create_lwe_secret_key(input_lwe_dimension)?;
let output_key: LweSecretKey64 = engine.create_lwe_secret_key(output_lwe_dimension)?;
let keyswitch_key = engine.create_lwe_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    noise,
)?;
let plaintext = engine.create_plaintext(&input)?;
let ciphertext_1 = engine.encrypt_lwe_ciphertext(&input_key, &plaintext, noise)?;
let mut ciphertext_2 = engine.zero_encrypt_lwe_ciphertext(&output_key, noise)?;

engine.discard_keyswitch_lwe_ciphertext(&mut ciphertext_2, &ciphertext_1, &keyswitch_key)?;
assert_eq!(ciphertext_2.lwe_dimension(), output_lwe_dimension);

engine.destroy(input_key)?;
engine.destroy(output_key)?;
engine.destroy(keyswitch_key)?;
engine.destroy(plaintext)?;
engine.destroy(ciphertext_1)?;
engine.destroy(ciphertext_2)?;

unsafe fn discard_keyswitch_lwe_ciphertext_unchecked(
    &mut self,
    output: &mut LweCiphertext64,
    input: &LweCiphertext64,
    ksk: &LweKeyswitchKey64
)

Unsafely keyswitch an LWE ciphertext.

impl LweCiphertextDiscardingKeyswitchEngine<LweKeyswitchKey64, LweCiphertextView64<'_>, LweCiphertextMutView64<'_>> for DefaultEngine

Description:

Implementation of LweCiphertextDiscardingKeyswitchEngine for DefaultEngine that operates on views containing 64 bits integers.

fn discard_keyswitch_lwe_ciphertext(
    &mut self,
    output: &mut LweCiphertextMutView64<'_>,
    input: &LweCiphertextView64<'_>,
    ksk: &LweKeyswitchKey64
) -> Result<(), LweCiphertextDiscardingKeyswitchError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{
    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.));
// Here a hard-set encoding is applied (shift by 50 bits)
let input = 3_u64 << 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: LweSecretKey64 = engine.create_lwe_secret_key(input_lwe_dimension)?;
let output_key: LweSecretKey64 = engine.create_lwe_secret_key(output_lwe_dimension)?;
let keyswitch_key = engine.create_lwe_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    noise,
)?;
let plaintext = engine.create_plaintext(&input)?;

let mut raw_ciphertext_1_container = vec![0_u64; input_key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_1: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext(&mut raw_ciphertext_1_container[..])?;
engine.discard_encrypt_lwe_ciphertext(&input_key, &mut ciphertext_1, &plaintext, noise)?;

// Convert MutView to View
let raw_ciphertext_1 = engine.consume_retrieve_lwe_ciphertext(ciphertext_1)?;
let ciphertext_1: LweCiphertextView64 = engine.create_lwe_ciphertext(&raw_ciphertext_1[..])?;

let mut raw_ciphertext_2_container = vec![0_u64; output_key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_2: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext(&mut raw_ciphertext_2_container[..])?;

engine.discard_keyswitch_lwe_ciphertext(&mut ciphertext_2, &ciphertext_1, &keyswitch_key)?;
assert_eq!(ciphertext_2.lwe_dimension(), output_lwe_dimension);

engine.destroy(input_key)?;
engine.destroy(output_key)?;
engine.destroy(keyswitch_key)?;
engine.destroy(plaintext)?;
engine.destroy(ciphertext_1)?;
engine.destroy(ciphertext_2)?;

unsafe fn discard_keyswitch_lwe_ciphertext_unchecked(
    &mut self,
    output: &mut LweCiphertextMutView64<'_>,
    input: &LweCiphertextView64<'_>,
    ksk: &LweKeyswitchKey64
)

Unsafely keyswitch an LWE ciphertext.

impl LweKeyswitchKeyCreationEngine<LweSecretKey64, LweSecretKey64, LweKeyswitchKey64> for DefaultEngine

Description:

Implementation of LweKeyswitchKeyCreationEngine for DefaultEngine that operates on 64 bits integers.

fn create_lwe_keyswitch_key(
    &mut self,
    input_key: &LweSecretKey64,
    output_key: &LweSecretKey64,
    decomposition_level_count: DecompositionLevelCount,
    decomposition_base_log: DecompositionBaseLog,
    noise: Variance
) -> Result<LweKeyswitchKey64, LweKeyswitchKeyCreationError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{
    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: LweSecretKey64 = engine.create_lwe_secret_key(input_lwe_dimension)?;
let output_key: LweSecretKey64 = engine.create_lwe_secret_key(output_lwe_dimension)?;

let keyswitch_key = engine.create_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);

engine.destroy(input_key)?;
engine.destroy(output_key)?;
engine.destroy(keyswitch_key)?;

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

Unsafely creates an LWE keyswitch key.

impl LweKeyswitchKeyEntity for LweKeyswitchKey64

type InputKeyDistribution = BinaryKeyDistribution

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

type OutputKeyDistribution = BinaryKeyDistribution

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

fn input_lwe_dimension(&self) -> LweDimension

Returns the input LWE dimension of the key.

fn output_lwe_dimension(&self) -> LweDimension

Returns the output lew dimension of the key.

fn decomposition_level_count(&self) -> DecompositionLevelCount

Returns the number of decomposition levels of the key.

fn decomposition_base_log(&self) -> DecompositionBaseLog

Returns the logarithm of the base used in the key.

impl LweSeededKeyswitchKeyToLweKeyswitchKeyTransformationEngine<LweSeededKeyswitchKey64, LweKeyswitchKey64> for DefaultEngine

fn transform_lwe_seeded_keyswitch_key_to_lwe_keyswitch_key(
    &mut self,
    lwe_seeded_keyswitch_key: LweSeededKeyswitchKey64
) -> Result<LweKeyswitchKey64, LweSeededKeyswitchKeyToLweKeyswitchKeyTransformationEngineError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{
    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: LweSecretKey64 = engine.create_lwe_secret_key(input_lwe_dimension)?;
let output_key: LweSecretKey64 = engine.create_lwe_secret_key(output_lwe_dimension)?;

let seeded_keyswitch_key = engine.create_lwe_seeded_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    noise,
)?;

let keyswitch_key = engine.transform_lwe_seeded_keyswitch_key_to_lwe_keyswitch_key(seeded_keyswitch_key)?;

assert_eq!(
assert_eq!(
assert_eq!(keyswitch_key.input_lwe_dimension(), input_lwe_dimension);
assert_eq!(keyswitch_key.output_lwe_dimension(), output_lwe_dimension);

engine.destroy(input_key)?;
engine.destroy(output_key)?;
engine.destroy(keyswitch_key)?;

unsafe fn transform_lwe_seeded_keyswitch_key_to_lwe_keyswitch_key_unchecked(
    &mut self,
    lwe_seeded_keyswitch_key: LweSeededKeyswitchKey64
) -> LweKeyswitchKey64

Unsafely transforms a seeded LWE keyswitch key into an LWE keyswitch key

impl PartialEq<LweKeyswitchKey64> for LweKeyswitchKey64

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

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

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

This method tests for !=.

impl Eq for LweKeyswitchKey64

impl StructuralEq for LweKeyswitchKey64

impl StructuralPartialEq for LweKeyswitchKey64