Struct concrete_core::backends::default::entities::GlweSecretKey64
source · [−]pub struct GlweSecretKey64(_);
Expand description
A structure representing a GLWE secret key with 64 bits of precision.
Trait Implementations
sourceimpl AbstractEntity for GlweSecretKey64
impl AbstractEntity for GlweSecretKey64
type Kind = GlweSecretKeyKind
type Kind = GlweSecretKeyKind
The kind of the entity.
sourceimpl Clone for GlweSecretKey64
impl Clone for GlweSecretKey64
sourcefn clone(&self) -> GlweSecretKey64
fn clone(&self) -> GlweSecretKey64
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl Debug for GlweSecretKey64
impl Debug for GlweSecretKey64
sourceimpl DestructionEngine<GlweSecretKey64> for DefaultEngine
impl DestructionEngine<GlweSecretKey64> for DefaultEngine
sourcefn destroy(
&mut self,
entity: GlweSecretKey64
) -> Result<(), DestructionError<Self::EngineError>>
fn destroy(
&mut self,
entity: GlweSecretKey64
) -> Result<(), DestructionError<Self::EngineError>>
Destroys an entity.
sourceunsafe fn destroy_unchecked(&mut self, entity: &mut GlweSecretKey64)
unsafe fn destroy_unchecked(&mut self, entity: &mut GlweSecretKey64)
Unsafely destroys an entity. Read more
sourceimpl GgswCiphertextScalarDiscardingEncryptionEngine<GlweSecretKey64, Plaintext64, GgswCiphertext64> for DefaultEngine
impl GgswCiphertextScalarDiscardingEncryptionEngine<GlweSecretKey64, Plaintext64, GgswCiphertext64> for DefaultEngine
Description:
Implementation of GgswCiphertextScalarDiscardingEncryptionEngine
for DefaultEngine
that
operates on 64 bits integers.
sourcefn discard_encrypt_scalar_ggsw_ciphertext(
&mut self,
key: &GlweSecretKey64,
output: &mut GgswCiphertext64,
input: &Plaintext64,
noise: Variance
) -> Result<(), GgswCiphertextScalarDiscardingEncryptionError<Self::EngineError>>
fn discard_encrypt_scalar_ggsw_ciphertext(
&mut self,
key: &GlweSecretKey64,
output: &mut GgswCiphertext64,
input: &Plaintext64,
noise: Variance
) -> Result<(), GgswCiphertextScalarDiscardingEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{
DecompositionBaseLog, DecompositionLevelCount, GlweDimension, PolynomialSize,
};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
let level = DecompositionLevelCount(1);
let base_log = DecompositionBaseLog(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = 3_u64 << 50;
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 key_1: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext = engine.create_plaintext(&input)?;
let mut ciphertext =
engine.encrypt_scalar_ggsw_ciphertext(&key_1, &plaintext, noise, level, base_log)?;
// We're going to re-encrypt the input with another secret key
// For this, it is required that the second secret key uses the same GLWE dimension
// and polynomial size as the first one.
let key_2: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
engine.discard_encrypt_scalar_ggsw_ciphertext(&key_2, &mut ciphertext, &plaintext, noise)?;
assert_eq!(ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext.polynomial_size(), polynomial_size);
engine.destroy(ciphertext)?;
engine.destroy(plaintext)?;
engine.destroy(key_1)?;
engine.destroy(key_2)?;
sourceunsafe fn discard_encrypt_scalar_ggsw_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut GgswCiphertext64,
input: &Plaintext64,
noise: Variance
)
unsafe fn discard_encrypt_scalar_ggsw_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut GgswCiphertext64,
input: &Plaintext64,
noise: Variance
)
Unsafely encrypts a GGSW ciphertext. Read more
sourceimpl GgswCiphertextScalarEncryptionEngine<GlweSecretKey64, Plaintext64, GgswCiphertext64> for DefaultEngine
impl GgswCiphertextScalarEncryptionEngine<GlweSecretKey64, Plaintext64, GgswCiphertext64> for DefaultEngine
Description:
Implementation of GgswCiphertextScalarEncryptionEngine
for DefaultEngine
that operates
on 64 bits integers.
sourcefn encrypt_scalar_ggsw_ciphertext(
&mut self,
key: &GlweSecretKey64,
input: &Plaintext64,
noise: Variance,
decomposition_level_count: DecompositionLevelCount,
decomposition_base_log: DecompositionBaseLog
) -> Result<GgswCiphertext64, GgswCiphertextScalarEncryptionError<Self::EngineError>>
fn encrypt_scalar_ggsw_ciphertext(
&mut self,
key: &GlweSecretKey64,
input: &Plaintext64,
noise: Variance,
decomposition_level_count: DecompositionLevelCount,
decomposition_base_log: DecompositionBaseLog
) -> Result<GgswCiphertext64, GgswCiphertextScalarEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{
DecompositionBaseLog, DecompositionLevelCount, GlweDimension, PolynomialSize,
};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
let level = DecompositionLevelCount(1);
let base_log = DecompositionBaseLog(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = 3_u64 << 50;
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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext = engine.create_plaintext(&input)?;
let ciphertext =
engine.encrypt_scalar_ggsw_ciphertext(&key, &plaintext, noise, level, base_log)?;
assert_eq!(ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext.polynomial_size(), polynomial_size);
engine.destroy(key)?;
engine.destroy(plaintext)?;
engine.destroy(ciphertext)?;
sourceunsafe fn encrypt_scalar_ggsw_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &Plaintext64,
noise: Variance,
decomposition_level_count: DecompositionLevelCount,
decomposition_base_log: DecompositionBaseLog
) -> GgswCiphertext64
unsafe fn encrypt_scalar_ggsw_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &Plaintext64,
noise: Variance,
decomposition_level_count: DecompositionLevelCount,
decomposition_base_log: DecompositionBaseLog
) -> GgswCiphertext64
Unsafely encrypts a plaintext vector into a GGSW ciphertext. Read more
sourceimpl GlweCiphertextDecryptionEngine<GlweSecretKey64, GlweCiphertext64, PlaintextVector64> for DefaultEngine
impl GlweCiphertextDecryptionEngine<GlweSecretKey64, GlweCiphertext64, PlaintextVector64> for DefaultEngine
Description:
Implementation of GlweCiphertextDecryptionEngine
for DefaultEngine
that operates on 64
bits integers.
sourcefn decrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
input: &GlweCiphertext64
) -> Result<PlaintextVector64, GlweCiphertextDecryptionError<Self::EngineError>>
fn decrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
input: &GlweCiphertext64
) -> Result<PlaintextVector64, GlweCiphertextDecryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; polynomial_size.0];
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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext = engine.encrypt_glwe_ciphertext(&key, &plaintext_vector, noise)?;
let decrypted_plaintext_vector = engine.decrypt_glwe_ciphertext(&key, &ciphertext)?;
assert_eq!(
engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext)?;
engine.destroy(decrypted_plaintext_vector)?;
sourceunsafe fn decrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &GlweCiphertext64
) -> PlaintextVector64
unsafe fn decrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &GlweCiphertext64
) -> PlaintextVector64
Unsafely decrypts a GLWE ciphertext into a plaintext vector. Read more
sourceimpl GlweCiphertextDiscardingDecryptionEngine<GlweSecretKey64, GlweCiphertext64, PlaintextVector64> for DefaultEngine
impl GlweCiphertextDiscardingDecryptionEngine<GlweSecretKey64, GlweCiphertext64, PlaintextVector64> for DefaultEngine
Description:
Implementation of GlweCiphertextDiscardingDecryptionEngine
for DefaultEngine
that
operates on 64 bits integers.
sourcefn discard_decrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
output: &mut PlaintextVector64,
input: &GlweCiphertext64
) -> Result<(), GlweCiphertextDiscardingDecryptionError<Self::EngineError>>
fn discard_decrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
output: &mut PlaintextVector64,
input: &GlweCiphertext64
) -> Result<(), GlweCiphertextDiscardingDecryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PlaintextCount, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let mut input = vec![3_u64 << 50; polynomial_size.0];
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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let mut plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext = engine.encrypt_glwe_ciphertext(&key, &plaintext_vector, noise)?;
engine.discard_decrypt_glwe_ciphertext(&key, &mut plaintext_vector, &ciphertext)?;
assert_eq!(plaintext_vector.plaintext_count(), PlaintextCount(4));
engine.destroy(ciphertext)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key)?;
sourceunsafe fn discard_decrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut PlaintextVector64,
input: &GlweCiphertext64
)
unsafe fn discard_decrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut PlaintextVector64,
input: &GlweCiphertext64
)
Unsafely decrypts a GLWE ciphertext . Read more
sourceimpl GlweCiphertextDiscardingEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweCiphertext64> for DefaultEngine
impl GlweCiphertextDiscardingEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweCiphertext64> for DefaultEngine
Description:
Implementation of GlweCiphertextDiscardingEncryptionEngine
for DefaultEngine
that
operates on 64 bits integers.
sourcefn discard_encrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
output: &mut GlweCiphertext64,
input: &PlaintextVector64,
noise: Variance
) -> Result<(), GlweCiphertextDiscardingEncryptionError<Self::EngineError>>
fn discard_encrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
output: &mut GlweCiphertext64,
input: &PlaintextVector64,
noise: Variance
) -> Result<(), GlweCiphertextDiscardingEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; 4];
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 key_1: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let mut ciphertext = engine.encrypt_glwe_ciphertext(&key_1, &plaintext_vector, noise)?;
// We're going to re-encrypt the input with another secret key
// For this, it is required that the second secret key uses the same GLWE dimension
// and polynomial size as the first one.
let key_2: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
engine.discard_encrypt_glwe_ciphertext(&key_2, &mut ciphertext, &plaintext_vector, noise)?;
assert_eq!(ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext.polynomial_size(), polynomial_size);
engine.destroy(ciphertext)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key_1)?;
engine.destroy(key_2)?;
sourceunsafe fn discard_encrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut GlweCiphertext64,
input: &PlaintextVector64,
noise: Variance
)
unsafe fn discard_encrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut GlweCiphertext64,
input: &PlaintextVector64,
noise: Variance
)
Unsafely encrypts a GLWE ciphertext . Read more
sourceimpl GlweCiphertextEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweCiphertext64> for DefaultEngine
impl GlweCiphertextEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweCiphertext64> for DefaultEngine
Description:
Implementation of GlweCiphertextEncryptionEngine
for DefaultEngine
that operates on 64
bits integers.
sourcefn encrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> Result<GlweCiphertext64, GlweCiphertextEncryptionError<Self::EngineError>>
fn encrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> Result<GlweCiphertext64, GlweCiphertextEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// There are always polynomial_size messages encrypted in the GLWE ciphertext
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; polynomial_size.0];
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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext = engine.encrypt_glwe_ciphertext(&key, &plaintext_vector, noise)?;
assert_eq!(ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext.polynomial_size(), polynomial_size);
engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext)?;
sourceunsafe fn encrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> GlweCiphertext64
unsafe fn encrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> GlweCiphertext64
Unsafely encrypts a plaintext vector into a GLWE ciphertext. Read more
sourceimpl GlweCiphertextVectorDecryptionEngine<GlweSecretKey64, GlweCiphertextVector64, PlaintextVector64> for DefaultEngine
impl GlweCiphertextVectorDecryptionEngine<GlweSecretKey64, GlweCiphertextVector64, PlaintextVector64> for DefaultEngine
Description:
Implementation of GlweCiphertextVectorDecryptionEngine
for DefaultEngine
that operates
on 64 bits integers.
sourcefn decrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
input: &GlweCiphertextVector64
) -> Result<PlaintextVector64, GlweCiphertextVectorDecryptionError<Self::EngineError>>
fn decrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
input: &GlweCiphertextVector64
) -> Result<PlaintextVector64, GlweCiphertextVectorDecryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PlaintextCount, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; 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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext_vector =
engine.encrypt_glwe_ciphertext_vector(&key, &plaintext_vector, noise)?;
let decrypted_plaintext_vector =
engine.decrypt_glwe_ciphertext_vector(&key, &ciphertext_vector)?;
assert_eq!(
engine.destroy(ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(decrypted_plaintext_vector)?;
engine.destroy(key)?;
sourceunsafe fn decrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &GlweCiphertextVector64
) -> PlaintextVector64
unsafe fn decrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &GlweCiphertextVector64
) -> PlaintextVector64
Unsafely decrypts a GLWE ciphertext vector. Read more
sourceimpl GlweCiphertextVectorDiscardingDecryptionEngine<GlweSecretKey64, GlweCiphertextVector64, PlaintextVector64> for DefaultEngine
impl GlweCiphertextVectorDiscardingDecryptionEngine<GlweSecretKey64, GlweCiphertextVector64, PlaintextVector64> for DefaultEngine
Description:
Implementation of GlweCiphertextVectorDiscardingDecryptionEngine
for DefaultEngine
that
operates on 64 bits integers.
sourcefn discard_decrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
output: &mut PlaintextVector64,
input: &GlweCiphertextVector64
) -> Result<(), GlweCiphertextVectorDiscardingDecryptionError<Self::EngineError>>
fn discard_decrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
output: &mut PlaintextVector64,
input: &GlweCiphertextVector64
) -> Result<(), GlweCiphertextVectorDiscardingDecryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PlaintextCount, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; 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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let mut plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext_vector =
engine.encrypt_glwe_ciphertext_vector(&key, &plaintext_vector, noise)?;
engine.discard_decrypt_glwe_ciphertext_vector(
&key,
&mut plaintext_vector,
&ciphertext_vector,
)?;
assert_eq!(plaintext_vector.plaintext_count(), PlaintextCount(8));
engine.destroy(ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key)?;
sourceunsafe fn discard_decrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut PlaintextVector64,
input: &GlweCiphertextVector64
)
unsafe fn discard_decrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut PlaintextVector64,
input: &GlweCiphertextVector64
)
Unsafely encrypts a GLWE ciphertext vector . Read more
sourceimpl GlweCiphertextVectorDiscardingEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweCiphertextVector64> for DefaultEngine
impl GlweCiphertextVectorDiscardingEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweCiphertextVector64> for DefaultEngine
Description:
Implementation of GlweCiphertextVectorDiscardingEncryptionEngine
for DefaultEngine
that
operates on 64 bits integers.
sourcefn discard_encrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
output: &mut GlweCiphertextVector64,
input: &PlaintextVector64,
noise: Variance
) -> Result<(), GlweCiphertextVectorDiscardingEncryptionError<Self::EngineError>>
fn discard_encrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
output: &mut GlweCiphertextVector64,
input: &PlaintextVector64,
noise: Variance
) -> Result<(), GlweCiphertextVectorDiscardingEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweCiphertextCount, GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; 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 key_1: GlweSecretKey64 =
engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let key_2: GlweSecretKey64 =
engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let mut ciphertext_vector =
engine.encrypt_glwe_ciphertext_vector(&key_1, &plaintext_vector, noise)?;
engine.discard_encrypt_glwe_ciphertext_vector(
&key_2,
&mut ciphertext_vector,
&plaintext_vector,
noise,
)?;
assert_eq!(ciphertext_vector.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext_vector.polynomial_size(), polynomial_size);
assert_eq!(
engine.destroy(ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key_1)?;
engine.destroy(key_2)?;
sourceunsafe fn discard_encrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut GlweCiphertextVector64,
input: &PlaintextVector64,
noise: Variance
)
unsafe fn discard_encrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
output: &mut GlweCiphertextVector64,
input: &PlaintextVector64,
noise: Variance
)
Unsafely encrypts a GLWE ciphertext vector . Read more
sourceimpl GlweCiphertextVectorEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweCiphertextVector64> for DefaultEngine
impl GlweCiphertextVectorEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweCiphertextVector64> for DefaultEngine
Description:
Implementation of GlweCiphertextVectorEncryptionEngine
for DefaultEngine
that operates
on 64 bits integers.
sourcefn encrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> Result<GlweCiphertextVector64, GlweCiphertextVectorEncryptionError<Self::EngineError>>
fn encrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> Result<GlweCiphertextVector64, GlweCiphertextVectorEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweCiphertextCount, GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; 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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let ciphertext_vector =
engine.encrypt_glwe_ciphertext_vector(&key, &plaintext_vector, noise)?;
assert_eq!(
assert_eq!(ciphertext_vector.polynomial_size(), polynomial_size);
assert_eq!(ciphertext_vector.glwe_dimension(), glwe_dimension);
engine.destroy(ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key)?;
sourceunsafe fn encrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> GlweCiphertextVector64
unsafe fn encrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> GlweCiphertextVector64
Unsafely encrypts a GLWE ciphertext vector. Read more
sourceimpl GlweCiphertextVectorZeroEncryptionEngine<GlweSecretKey64, GlweCiphertextVector64> for DefaultEngine
impl GlweCiphertextVectorZeroEncryptionEngine<GlweSecretKey64, GlweCiphertextVector64> for DefaultEngine
Description:
Implementation of GlweCiphertextVectorZeroEncryptionEngine
for DefaultEngine
that
operates on 64 bits integers.
sourcefn zero_encrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
noise: Variance,
count: GlweCiphertextCount
) -> Result<GlweCiphertextVector64, GlweCiphertextVectorZeroEncryptionError<Self::EngineError>>
fn zero_encrypt_glwe_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
noise: Variance,
count: GlweCiphertextCount
) -> Result<GlweCiphertextVector64, GlweCiphertextVectorZeroEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweCiphertextCount, GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(1024);
let ciphertext_count = GlweCiphertextCount(3);
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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let ciphertext_vector =
engine.zero_encrypt_glwe_ciphertext_vector(&key, noise, ciphertext_count)?;
assert_eq!(ciphertext_vector.glwe_ciphertext_count(), ciphertext_count);
assert_eq!(ciphertext_vector.polynomial_size(), polynomial_size);
assert_eq!(ciphertext_vector.glwe_dimension(), glwe_dimension);
engine.destroy(ciphertext_vector)?;
engine.destroy(key)?;
sourceunsafe fn zero_encrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
noise: Variance,
count: GlweCiphertextCount
) -> GlweCiphertextVector64
unsafe fn zero_encrypt_glwe_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
noise: Variance,
count: GlweCiphertextCount
) -> GlweCiphertextVector64
Unsafely encrypts zero in a GLWE ciphertext vector. Read more
sourceimpl GlweCiphertextZeroEncryptionEngine<GlweSecretKey64, GlweCiphertext64> for DefaultEngine
impl GlweCiphertextZeroEncryptionEngine<GlweSecretKey64, GlweCiphertext64> for DefaultEngine
Description:
Implementation of GlweCiphertextZeroEncryptionEngine
for DefaultEngine
that operates on
64 bits integers.
sourcefn zero_encrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
noise: Variance
) -> Result<GlweCiphertext64, GlweCiphertextZeroEncryptionError<Self::EngineError>>
fn zero_encrypt_glwe_ciphertext(
&mut self,
key: &GlweSecretKey64,
noise: Variance
) -> Result<GlweCiphertext64, GlweCiphertextZeroEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(1024);
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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let ciphertext = engine.zero_encrypt_glwe_ciphertext(&key, noise)?;
assert_eq!(ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(ciphertext.polynomial_size(), polynomial_size);
engine.destroy(key)?;
engine.destroy(ciphertext)?;
sourceunsafe fn zero_encrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
noise: Variance
) -> GlweCiphertext64
unsafe fn zero_encrypt_glwe_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
noise: Variance
) -> GlweCiphertext64
Unsafely encrypts a zero in a GLWE ciphertext. Read more
sourceimpl GlweSecretKeyCreationEngine<GlweSecretKey64> for DefaultEngine
impl GlweSecretKeyCreationEngine<GlweSecretKey64> for DefaultEngine
Description:
Implementation of GlweSecretKeyCreationEngine
for DefaultEngine
that operates on
64 bits integers.
sourcefn create_glwe_secret_key(
&mut self,
glwe_dimension: GlweDimension,
polynomial_size: PolynomialSize
) -> Result<GlweSecretKey64, GlweSecretKeyCreationError<Self::EngineError>>
fn create_glwe_secret_key(
&mut self,
glwe_dimension: GlweDimension,
polynomial_size: PolynomialSize
) -> Result<GlweSecretKey64, GlweSecretKeyCreationError<Self::EngineError>>
Example:
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// 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 glwe_secret_key: GlweSecretKey64 =
engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
assert_eq!(glwe_secret_key.glwe_dimension(), glwe_dimension);
assert_eq!(glwe_secret_key.polynomial_size(), polynomial_size);
engine.destroy(glwe_secret_key)?;
sourceunsafe fn create_glwe_secret_key_unchecked(
&mut self,
glwe_dimension: GlweDimension,
polynomial_size: PolynomialSize
) -> GlweSecretKey64
unsafe fn create_glwe_secret_key_unchecked(
&mut self,
glwe_dimension: GlweDimension,
polynomial_size: PolynomialSize
) -> GlweSecretKey64
Unsafely creates a new GLWE secret key. Read more
sourceimpl GlweSecretKeyEntity for GlweSecretKey64
impl GlweSecretKeyEntity for GlweSecretKey64
type KeyDistribution = BinaryKeyDistribution
type KeyDistribution = BinaryKeyDistribution
The distribution of this key.
sourcefn glwe_dimension(&self) -> GlweDimension
fn glwe_dimension(&self) -> GlweDimension
Returns the GLWE dimension of the key.
sourcefn polynomial_size(&self) -> PolynomialSize
fn polynomial_size(&self) -> PolynomialSize
Returns the polynomial size of the key.
sourceimpl GlweSeededCiphertextEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweSeededCiphertext64> for DefaultEngine
impl GlweSeededCiphertextEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweSeededCiphertext64> for DefaultEngine
Description:
Implementation of GlweSeededCiphertextEncryptionEngine
for DefaultEngine
that operates
on 64 bits integers.
sourcefn encrypt_glwe_seeded_ciphertext(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> Result<GlweSeededCiphertext64, GlweSeededCiphertextEncryptionError<Self::EngineError>>
fn encrypt_glwe_seeded_ciphertext(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> Result<GlweSeededCiphertext64, GlweSeededCiphertextEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// There are always polynomial_size messages encrypted in the GLWE ciphertext
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; polynomial_size.0];
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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let seeded_ciphertext =
engine.encrypt_glwe_seeded_ciphertext(&key, &plaintext_vector, noise)?;
assert_eq!(seeded_ciphertext.glwe_dimension(), glwe_dimension);
assert_eq!(seeded_ciphertext.polynomial_size(), polynomial_size);
engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(seeded_ciphertext)?;
sourceunsafe fn encrypt_glwe_seeded_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> GlweSeededCiphertext64
unsafe fn encrypt_glwe_seeded_ciphertext_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> GlweSeededCiphertext64
Unsafely encrypts a seeded GLWE ciphertext. Read more
sourceimpl GlweSeededCiphertextVectorEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweSeededCiphertextVector64> for DefaultEngine
impl GlweSeededCiphertextVectorEncryptionEngine<GlweSecretKey64, PlaintextVector64, GlweSeededCiphertextVector64> for DefaultEngine
Description:
Implementation of GlweSeededCiphertextVectorEncryptionEngine
for DefaultEngine
that
operates on 64 bits integers.
sourcefn encrypt_glwe_seeded_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> Result<GlweSeededCiphertextVector64, GlweSeededCiphertextVectorEncryptionError<Self::EngineError>>
fn encrypt_glwe_seeded_ciphertext_vector(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> Result<GlweSeededCiphertextVector64, GlweSeededCiphertextVectorEncryptionError<Self::EngineError>>
Example:
use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{GlweCiphertextCount, GlweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// Here a hard-set encoding is applied (shift by 50 bits)
let input = vec![3_u64 << 50; 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 key: GlweSecretKey64 = engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
let plaintext_vector = engine.create_plaintext_vector(&input)?;
let seeded_ciphertext_vector =
engine.encrypt_glwe_seeded_ciphertext_vector(&key, &plaintext_vector, noise)?;
assert_eq!(
assert_eq!(seeded_ciphertext_vector.polynomial_size(), polynomial_size);
assert_eq!(seeded_ciphertext_vector.glwe_dimension(), glwe_dimension);
engine.destroy(seeded_ciphertext_vector)?;
engine.destroy(plaintext_vector)?;
engine.destroy(key)?;
sourceunsafe fn encrypt_glwe_seeded_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> GlweSeededCiphertextVector64
unsafe fn encrypt_glwe_seeded_ciphertext_vector_unchecked(
&mut self,
key: &GlweSecretKey64,
input: &PlaintextVector64,
noise: Variance
) -> GlweSeededCiphertextVector64
Unsafely encrypts a GLWE seeded ciphertext vector. Read more
sourceimpl GlweToLweSecretKeyTransformationEngine<GlweSecretKey64, LweSecretKey64> for DefaultEngine
impl GlweToLweSecretKeyTransformationEngine<GlweSecretKey64, LweSecretKey64> for DefaultEngine
sourcefn transform_glwe_secret_key_to_lwe_secret_key(
&mut self,
glwe_secret_key: GlweSecretKey64
) -> Result<LweSecretKey64, GlweToLweSecretKeyTransformationEngineError<Self::EngineError>>
fn transform_glwe_secret_key_to_lwe_secret_key(
&mut self,
glwe_secret_key: GlweSecretKey64
) -> Result<LweSecretKey64, GlweToLweSecretKeyTransformationEngineError<Self::EngineError>>
Example
use concrete_commons::parameters::{GlweDimension, LweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let glwe_dimension = GlweDimension(2);
let polynomial_size = PolynomialSize(4);
// 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 glwe_secret_key: GlweSecretKey64 =
engine.create_glwe_secret_key(glwe_dimension, polynomial_size)?;
assert_eq!(glwe_secret_key.glwe_dimension(), glwe_dimension);
assert_eq!(glwe_secret_key.polynomial_size(), polynomial_size);
let lwe_secret_key = engine.transform_glwe_secret_key_to_lwe_secret_key(glwe_secret_key)?;
assert_eq!(lwe_secret_key.lwe_dimension(), LweDimension(8));
engine.destroy(lwe_secret_key)?;
sourceunsafe fn transform_glwe_secret_key_to_lwe_secret_key_unchecked(
&mut self,
glwe_secret_key: GlweSecretKey64
) -> LweSecretKey64
unsafe fn transform_glwe_secret_key_to_lwe_secret_key_unchecked(
&mut self,
glwe_secret_key: GlweSecretKey64
) -> LweSecretKey64
Unsafely transforms a GLWE secret key into an LWE secret key Read more
sourceimpl LweBootstrapKeyCreationEngine<LweSecretKey64, GlweSecretKey64, LweBootstrapKey64> for DefaultEngine
impl LweBootstrapKeyCreationEngine<LweSecretKey64, GlweSecretKey64, LweBootstrapKey64> for DefaultEngine
Description:
Implementation of LweBootstrapKeyCreationEngine
for DefaultEngine
that operates on
64 bits integers. It outputs a bootstrap key in the standard domain.
sourcefn 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>>
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.));
// 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: 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)?;
sourceunsafe 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
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. Read more
sourceimpl LweSeededBootstrapKeyCreationEngine<LweSecretKey64, GlweSecretKey64, LweSeededBootstrapKey64> for DefaultEngine
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.
sourcefn 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>>
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)?;
sourceunsafe 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
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. Read more
sourceimpl LweToGlweSecretKeyTransformationEngine<LweSecretKey64, GlweSecretKey64> for DefaultEngine
impl LweToGlweSecretKeyTransformationEngine<LweSecretKey64, GlweSecretKey64> for DefaultEngine
sourcefn transform_lwe_secret_key_to_glwe_secret_key(
&mut self,
lwe_secret_key: LweSecretKey64,
polynomial_size: PolynomialSize
) -> Result<GlweSecretKey64, LweToGlweSecretKeyTransformationEngineError<Self::EngineError>>
fn transform_lwe_secret_key_to_glwe_secret_key(
&mut self,
lwe_secret_key: LweSecretKey64,
polynomial_size: PolynomialSize
) -> Result<GlweSecretKey64, LweToGlweSecretKeyTransformationEngineError<Self::EngineError>>
Example
use concrete_commons::parameters::{GlweDimension, LweDimension, PolynomialSize};
use concrete_core::prelude::*;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(8);
let polynomial_size = PolynomialSize(4);
// 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_secret_key: LweSecretKey64 = engine.create_lwe_secret_key(lwe_dimension)?;
assert_eq!(lwe_secret_key.lwe_dimension(), lwe_dimension);
let glwe_secret_key =
engine.transform_lwe_secret_key_to_glwe_secret_key(lwe_secret_key, polynomial_size)?;
assert_eq!(glwe_secret_key.glwe_dimension(), GlweDimension(2));
assert_eq!(glwe_secret_key.polynomial_size(), polynomial_size);
engine.destroy(glwe_secret_key)?;
sourceunsafe fn transform_lwe_secret_key_to_glwe_secret_key_unchecked(
&mut self,
lwe_secret_key: LweSecretKey64,
polynomial_size: PolynomialSize
) -> GlweSecretKey64
unsafe fn transform_lwe_secret_key_to_glwe_secret_key_unchecked(
&mut self,
lwe_secret_key: LweSecretKey64,
polynomial_size: PolynomialSize
) -> GlweSecretKey64
Unsafely transforms an LWE secret key into a GLWE secret key Read more
sourceimpl PackingKeyswitchKeyCreationEngine<LweSecretKey64, GlweSecretKey64, PackingKeyswitchKey64> for DefaultEngine
impl PackingKeyswitchKeyCreationEngine<LweSecretKey64, GlweSecretKey64, PackingKeyswitchKey64> for DefaultEngine
Description:
Implementation of PackingKeyswitchKeyCreationEngine
for DefaultEngine
that
operates on 64 bits integers.
sourcefn create_packing_keyswitch_key(
&mut self,
input_key: &LweSecretKey64,
output_key: &GlweSecretKey64,
decomposition_level_count: DecompositionLevelCount,
decomposition_base_log: DecompositionBaseLog,
noise: Variance
) -> Result<PackingKeyswitchKey64, PackingKeyswitchKeyCreationError<Self::EngineError>>
fn create_packing_keyswitch_key(
&mut self,
input_key: &LweSecretKey64,
output_key: &GlweSecretKey64,
decomposition_level_count: DecompositionLevelCount,
decomposition_base_log: DecompositionBaseLog,
noise: Variance
) -> Result<PackingKeyswitchKey64, PackingKeyswitchKeyCreationError<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 packing_keyswitch_key = engine.create_lwe_keyswitch_key(
&input_key,
&output_key,
decomposition_level_count,
decomposition_base_log,
noise,
)?;
assert_eq!(
assert_eq!(
assert_eq!(packing_keyswitch_key.input_lwe_dimension(), input_lwe_dimension);
assert_eq!(packing_keyswitch_key.output_lwe_dimension(), output_lwe_dimension);
engine.destroy(input_key)?;
engine.destroy(output_key)?;
engine.destroy(packing_keyswitch_key)?;
sourceunsafe fn create_packing_keyswitch_key_unchecked(
&mut self,
input_key: &LweSecretKey64,
output_key: &GlweSecretKey64,
decomposition_level_count: DecompositionLevelCount,
decomposition_base_log: DecompositionBaseLog,
noise: Variance
) -> PackingKeyswitchKey64
unsafe fn create_packing_keyswitch_key_unchecked(
&mut self,
input_key: &LweSecretKey64,
output_key: &GlweSecretKey64,
decomposition_level_count: DecompositionLevelCount,
decomposition_base_log: DecompositionBaseLog,
noise: Variance
) -> PackingKeyswitchKey64
Unsafely creates a packing keyswitch key. Read more
sourceimpl PartialEq<GlweSecretKey64> for GlweSecretKey64
impl PartialEq<GlweSecretKey64> for GlweSecretKey64
sourcefn eq(&self, other: &GlweSecretKey64) -> bool
fn eq(&self, other: &GlweSecretKey64) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
sourcefn ne(&self, other: &GlweSecretKey64) -> bool
fn ne(&self, other: &GlweSecretKey64) -> bool
This method tests for !=
.
impl Eq for GlweSecretKey64
impl StructuralEq for GlweSecretKey64
impl StructuralPartialEq for GlweSecretKey64
Auto Trait Implementations
impl RefUnwindSafe for GlweSecretKey64
impl Send for GlweSecretKey64
impl Sync for GlweSecretKey64
impl Unpin for GlweSecretKey64
impl UnwindSafe for GlweSecretKey64
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more