Struct LwePrivateFunctionalPackingKeyswitchKey32 

pub struct LwePrivateFunctionalPackingKeyswitchKey32(/* private fields */);

A structure representing a private functional packing keyswitch key with 32 bits of precision.

Trait Implementations

impl AbstractEntity for LwePrivateFunctionalPackingKeyswitchKey32

type Kind = LwePrivateFunctionalPackingKeyswitchKeyKind

The kind of the entity.

impl Clone for LwePrivateFunctionalPackingKeyswitchKey32

fn clone(&self) -> LwePrivateFunctionalPackingKeyswitchKey32

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LwePrivateFunctionalPackingKeyswitchKey32

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

Formats the value using the given formatter.

impl LweCiphertextVectorGlweCiphertextDiscardingPrivateFunctionalPackingKeyswitchEngine<LwePrivateFunctionalPackingKeyswitchKey32, LweCiphertextVector32, GlweCiphertext32> for DefaultEngine

Description:

Implementation of LweCiphertextVectorGlweCiphertextDiscardingPrivateFunctionalPackingKeyswitchEngine for DefaultEngine that operates on 32 bits integers.

fn discard_private_functional_packing_keyswitch_lwe_ciphertext_vector( &mut self, output: &mut GlweCiphertext32, input: &LweCiphertextVector32, pfpksk: &LwePrivateFunctionalPackingKeyswitchKey32, ) -> Result<(), LweCiphertextVectorGlweCiphertextDiscardingPrivateFunctionalPackingKeyswitchError<Self::EngineError>>

Example:

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

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(6);
let output_glwe_dimension = GlweDimension(3);
let decomposition_level_count = DecompositionLevelCount(2);
let decomposition_base_log = DecompositionBaseLog(8);
let polynomial_size = PolynomialSize(256);
let noise = Variance(2_f64.powf(-25.));
// Here a hard-set encoding is applied (shift by 20 bits)
let input_vector = vec![3_u32 << 20, 256];

// 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: LweSecretKey32 = engine.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: GlweSecretKey32 =
    engine.generate_new_glwe_secret_key(output_glwe_dimension, polynomial_size)?;
let val = vec![1_u32; output_key.polynomial_size().0];
let polynomial: CleartextVector32 = engine.create_cleartext_vector_from(&val)?;
let private_functional_packing_keyswitch_key = engine
    .generate_new_lwe_private_functional_packing_keyswitch_key(
        &input_key,
        &output_key,
        decomposition_level_count,
        decomposition_base_log,
        StandardDev(noise.get_standard_dev()),
        &|x| x,
        &polynomial,
    )?;
let plaintext_vector = engine.create_plaintext_vector_from(&input_vector)?;
let ciphertext_vector =
    engine.encrypt_lwe_ciphertext_vector(&input_key, &plaintext_vector, noise)?;
let mut ciphertext_output = engine.zero_encrypt_glwe_ciphertext(&output_key, noise)?;

engine.discard_private_functional_packing_keyswitch_lwe_ciphertext_vector(
    &mut ciphertext_output,
    &ciphertext_vector,
    &private_functional_packing_keyswitch_key,
)?;
assert_eq!(ciphertext_output.glwe_dimension(), output_glwe_dimension);

unsafe fn discard_private_functional_packing_keyswitch_lwe_ciphertext_vector_unchecked( &mut self, output: &mut GlweCiphertext32, input: &LweCiphertextVector32, pfpksk: &LwePrivateFunctionalPackingKeyswitchKey32, )

Unsafely keyswitches an LWE ciphertext vector using a private functional packing keyswitch key.

impl LwePrivateFunctionalLwePackingKeyswitchKeyGenerationEngine<LweSecretKey32, GlweSecretKey32, LwePrivateFunctionalPackingKeyswitchKey32, CleartextVector32, u32> for DefaultEngine

Description:

Implementation of LwePrivateFunctionalLwePackingKeyswitchKeyGenerationEngine for DefaultEngine that operates on 32 bits integers. Note that the function applied during keyswitching is of the form m -> m * pol for a polynomial pol. The input polynomial should be a cleartext vector containing the coefficients of pol starting with the constant term.

fn generate_new_lwe_private_functional_packing_keyswitch_key( &mut self, input_key: &LweSecretKey32, output_key: &GlweSecretKey32, decomposition_level_count: DecompositionLevelCount, decomposition_base_log: DecompositionBaseLog, noise: StandardDev, f: &dyn Fn(u32) -> u32, polynomial: &CleartextVector32, ) -> Result<LwePrivateFunctionalPackingKeyswitchKey32, LwePrivateFunctionalLwePackingKeyswitchKeyGenerationError<Self::EngineError>>

Example:

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

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(10);
let output_glwe_dimension = GlweDimension(3);
let polynomial_size = PolynomialSize(256);
let decomposition_base_log = DecompositionBaseLog(3);
let decomposition_level_count = DecompositionLevelCount(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 input_key: LweSecretKey32 = engine.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: GlweSecretKey32 = engine.generate_new_glwe_secret_key(output_glwe_dimension,
polynomial_size)?;

let val = vec![1_u32; output_key.polynomial_size().0];
let polynomial: CleartextVector32 = engine.create_cleartext_vector_from(&val)?;
let private_functional_packing_keyswitch_key = engine
.generate_new_lwe_private_functional_packing_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    StandardDev(noise.get_standard_dev()),
    &|x|x,
    &polynomial,
)?;
assert_eq!(
assert_eq!(
assert_eq!(private_functional_packing_keyswitch_key.input_lwe_dimension(),
input_lwe_dimension);
assert_eq!(private_functional_packing_keyswitch_key.output_glwe_dimension(),
output_glwe_dimension);

unsafe fn generate_new_lwe_private_functional_packing_keyswitch_key_unchecked( &mut self, input_key: &LweSecretKey32, output_key: &GlweSecretKey32, decomposition_level_count: DecompositionLevelCount, decomposition_base_log: DecompositionBaseLog, noise: StandardDev, f: &dyn Fn(u32) -> u32, polynomial: &CleartextVector32, ) -> LwePrivateFunctionalPackingKeyswitchKey32

Unsafely generates a new private functional packing keyswitch key.

impl LwePrivateFunctionalPackingKeyswitchKeyEntity for LwePrivateFunctionalPackingKeyswitchKey32

fn input_lwe_dimension(&self) -> LweDimension

Returns the input LWE dimension of the key.

fn output_glwe_dimension(&self) -> GlweDimension

Returns the output GLWE dimension of the key.

fn output_polynomial_size(&self) -> PolynomialSize

Returns the output polynomial degree 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 PartialEq for LwePrivateFunctionalPackingKeyswitchKey32

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for LwePrivateFunctionalPackingKeyswitchKey32

impl StructuralPartialEq for LwePrivateFunctionalPackingKeyswitchKey32