Struct concrete_core::backends::core::entities::LweCiphertextVector32

pub struct LweCiphertextVector32(_);

A structure representing a vector of LWE ciphertexts with 32 bits of precision.

Trait Implementations

impl AbstractEntity for LweCiphertextVector32

type Kind = LweCiphertextVectorKind

The kind of the entity.

impl Clone for LweCiphertextVector32

fn clone(&self) -> LweCiphertextVector32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LweCiphertextVector32

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LweCiphertextVector32

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl DestructionEngine<LweCiphertextVector32> for CoreEngine

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

Destroys an entity.

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

Unsafely destroys an entity.

impl LweCiphertextVectorDecryptionEngine<LweSecretKey32, LweCiphertextVector32, PlaintextVector32> for CoreEngine

Description:

Implementation of LweCiphertextVectorDecryptionEngine for CoreEngine that operates on 32 bits integers.

fn decrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertextVector32
) -> Result<PlaintextVector32, LweCiphertextVectorDecryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{LweCiphertextCount, LweDimension, PlaintextCount};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 18];
let noise = Variance(2_f64.powf(-25.));

let mut engine = CoreEngine::new()?;
let key: LweSecretKey32 = engine.create_lwe_secret_key(lwe_dimension)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector(&input)?;
let ciphertext_vector: LweCiphertextVector32 =
    engine.encrypt_lwe_ciphertext_vector(&key, &plaintext_vector, noise)?;

let decrypted_plaintext_vector =
    engine.decrypt_lwe_ciphertext_vector(&key, &ciphertext_vector)?;

assert_eq!(
    decrypted_plaintext_vector.plaintext_count(),
    PlaintextCount(18)
);

engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext_vector)?;
engine.destroy(decrypted_plaintext_vector)?;

unsafe fn decrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &LweCiphertextVector32
) -> PlaintextVector32

Unsafely decrypts an LWE ciphertext vector.

impl LweCiphertextVectorDiscardingAffineTransformationEngine<LweCiphertextVector32, CleartextVector32, Plaintext32, LweCiphertext32> for CoreEngine

Description:

Implementation of LweCiphertextVectorDiscardingAffineTransformationEngine for CoreEngine that operates on 32 bits integers.

fn discard_affine_transform_lwe_ciphertext_vector(
    &mut self,
    output: &mut LweCiphertext32,
    inputs: &LweCiphertextVector32,
    weights: &CleartextVector32,
    bias: &Plaintext32
) -> Result<(), LweCiphertextVectorDiscardingAffineTransformationError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::LweDimension;
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
// Here a hard-set encoding is applied (shift by 20 bits)
let input_vector = vec![3_u32 << 20; 8];
let weights_input = vec![2_u32; 8];
let bias_input = 8_u32 << 20;
let noise = Variance::from_variance(2_f64.powf(-25.));

let mut engine = CoreEngine::new()?;
let key: LweSecretKey32 = engine.create_lwe_secret_key(lwe_dimension)?;
let weights: CleartextVector32 = engine.create_cleartext_vector(&input_vector)?;
let bias: Plaintext32 = engine.create_plaintext(&bias_input)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector(&input_vector)?;
let ciphertext_vector = engine.encrypt_lwe_ciphertext_vector(&key, &plaintext_vector, noise)?;
let mut output_ciphertext = engine.zero_encrypt_lwe_ciphertext(&key, noise)?;

engine.discard_affine_transform_lwe_ciphertext_vector(
    &mut output_ciphertext,
    &ciphertext_vector,
    &weights,
    &bias,
)?;
assert_eq!(output_ciphertext.lwe_dimension(), lwe_dimension);

engine.destroy(key)?;
engine.destroy(weights)?;
engine.destroy(bias)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext_vector)?;
engine.destroy(output_ciphertext)?;

unsafe fn discard_affine_transform_lwe_ciphertext_vector_unchecked(
    &mut self,
    output: &mut LweCiphertext32,
    inputs: &LweCiphertextVector32,
    weights: &CleartextVector32,
    bias: &Plaintext32
)

Unsafely performs the affine transform of an LWE ciphertext vector.

impl LweCiphertextVectorDiscardingDecryptionEngine<LweSecretKey32, LweCiphertextVector32, PlaintextVector32> for CoreEngine

Description:

Implementation of LweCiphertextVectorDiscardingDecryptionEngine for CoreEngine that operates on 32 bits integers.

fn discard_decrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    output: &mut PlaintextVector32,
    input: &LweCiphertextVector32
) -> Result<(), LweCiphertextVectorDiscardingDecryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{LweCiphertextCount, LweDimension, PlaintextCount};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 18];
let noise = Variance(2_f64.powf(-25.));

let mut engine = CoreEngine::new()?;
let key: LweSecretKey32 = engine.create_lwe_secret_key(lwe_dimension)?;
let mut plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector(&input)?;
let ciphertext_vector: LweCiphertextVector32 =
    engine.encrypt_lwe_ciphertext_vector(&key, &plaintext_vector, noise)?;

engine.discard_decrypt_lwe_ciphertext_vector(
    &key,
    &mut plaintext_vector,
    &ciphertext_vector,
)?;
assert_eq!(plaintext_vector.plaintext_count(), PlaintextCount(18));

engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext_vector)?;

unsafe fn discard_decrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    output: &mut PlaintextVector32,
    input: &LweCiphertextVector32
)

Unsafely decrypts an LWE ciphertext vector.

impl LweCiphertextVectorDiscardingEncryptionEngine<LweSecretKey32, PlaintextVector32, LweCiphertextVector32> for CoreEngine

Description:

Implementation of LweCiphertextVectorDiscardingEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn discard_encrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertextVector32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<(), LweCiphertextVectorDiscardingEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{LweCiphertextCount, LweDimension};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 3];
let noise = Variance(2_f64.powf(-25.));

let mut engine = CoreEngine::new()?;
let key: LweSecretKey32 = engine.create_lwe_secret_key(lwe_dimension)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector(&input)?;
let mut ciphertext_vector: LweCiphertextVector32 =
    engine.zero_encrypt_lwe_ciphertext_vector(&key, noise, LweCiphertextCount(3))?;

engine.discard_encrypt_lwe_ciphertext_vector(
    &key,
    &mut ciphertext_vector,
    &plaintext_vector,
    noise,
)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(

engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext_vector)?;

unsafe fn discard_encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    output: &mut LweCiphertextVector32,
    input: &PlaintextVector32,
    noise: Variance
)

Unsafely encryprs an LWE ciphertext vector.

impl LweCiphertextVectorEncryptionEngine<LweSecretKey32, PlaintextVector32, LweCiphertextVector32> for CoreEngine

Description:

Implementation of LweCiphertextVectorEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn encrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> Result<LweCiphertextVector32, LweCiphertextVectorEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{LweCiphertextCount, LweDimension};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(6);
// Here a hard-set encoding is applied (shift by 20 bits)
let input = vec![3_u32 << 20; 3];
let noise = Variance(2_f64.powf(-25.));

let mut engine = CoreEngine::new()?;
let key: LweSecretKey32 = engine.create_lwe_secret_key(lwe_dimension)?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector(&input)?;

let mut ciphertext_vector: LweCiphertextVector32 =
    engine.encrypt_lwe_ciphertext_vector(&key, &plaintext_vector, noise)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(

engine.destroy(key)?;
engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext_vector)?;

unsafe fn encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    input: &PlaintextVector32,
    noise: Variance
) -> LweCiphertextVector32

Unsafely encrypts an LWE ciphertext vector.

impl LweCiphertextVectorEntity for LweCiphertextVector32

type KeyDistribution = BinaryKeyDistribution

The distribution of key the ciphertext was encrypted with.

fn lwe_dimension(&self) -> LweDimension

Returns the LWE dimension of the ciphertexts.

fn lwe_ciphertext_count(&self) -> LweCiphertextCount

Returns the number of ciphertexts contained in the vector.

impl LweCiphertextVectorTrivialEncryptionEngine<PlaintextVector32, LweCiphertextVector32> for CoreEngine

fn trivially_encrypt_lwe_ciphertext_vector(
    &mut self,
    lwe_size: LweSize,
    input: &PlaintextVector32
) -> Result<LweCiphertextVector32, LweCiphertextVectorTrivialEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::LweSize;
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_size = LweSize(10);
let input = vec![3_u32 << 20; 3];

let mut engine = CoreEngine::new()?;
let plaintext_vector: PlaintextVector32 = engine.create_plaintext_vector(&input)?;
let ciphertext_vector: LweCiphertextVector32 =
    engine.trivially_encrypt_lwe_ciphertext_vector(lwe_size, &plaintext_vector)?;

assert_eq!(ciphertext_vector.lwe_dimension().to_lwe_size(), lwe_size);
assert_eq!(
    ciphertext_vector.lwe_ciphertext_count().0,
    plaintext_vector.plaintext_count().0
);

engine.destroy(plaintext_vector)?;
engine.destroy(ciphertext_vector)?;

unsafe fn trivially_encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    lwe_size: LweSize,
    input: &PlaintextVector32
) -> LweCiphertextVector32

Unsafely creates the trivial LWE encryption of the plaintext vector.

impl LweCiphertextVectorZeroEncryptionEngine<LweSecretKey32, LweCiphertextVector32> for CoreEngine

Description:

Implementation of LweCiphertextVectorZeroEncryptionEngine for CoreEngine that operates on 32 bits integers.

fn zero_encrypt_lwe_ciphertext_vector(
    &mut self,
    key: &LweSecretKey32,
    noise: Variance,
    count: LweCiphertextCount
) -> Result<LweCiphertextVector32, LweCiphertextVectorZeroEncryptionError<Self::EngineError>>

Example:

use concrete_commons::dispersion::Variance;
use concrete_commons::parameters::{LweCiphertextCount, LweDimension};
use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let lwe_dimension = LweDimension(2);
let ciphertext_count = LweCiphertextCount(3);
let noise = Variance(2_f64.powf(-25.));

let mut engine = CoreEngine::new()?;
let key: LweSecretKey32 = engine.create_lwe_secret_key(lwe_dimension)?;

let ciphertext_vector =
    engine.zero_encrypt_lwe_ciphertext_vector(&key, noise, ciphertext_count)?;
assert_eq!(ciphertext_vector.lwe_dimension(), lwe_dimension);
assert_eq!(ciphertext_vector.lwe_ciphertext_count(), ciphertext_count);

engine.destroy(key)?;
engine.destroy(ciphertext_vector)?;

unsafe fn zero_encrypt_lwe_ciphertext_vector_unchecked(
    &mut self,
    key: &LweSecretKey32,
    noise: Variance,
    count: LweCiphertextCount
) -> LweCiphertextVector32

Unsafely encrypts zeros in an LWE ciphertext vector.

impl PartialEq<LweCiphertextVector32> for LweCiphertextVector32

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

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

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

This method tests for !=.

impl Serialize for LweCiphertextVector32

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Eq for LweCiphertextVector32

impl StructuralEq for LweCiphertextVector32

impl StructuralPartialEq for LweCiphertextVector32