Struct LweCiphertextView64 

pub struct LweCiphertextView64<'a>(/* private fields */);

A structure representing an LWE ciphertext view, with 64 bits of precision.

By view here, we mean that the entity does not own the data, but immutably borrows it.

Notes:

This view is not Clone as Clone for a slice is not defined. It is not Deserialize either, as Deserialize of a slice is not defined. Immutable variant.

Trait Implementations

impl AbstractEntity for LweCiphertextView64<'_>

type Kind = LweCiphertextKind

The kind of the entity.

impl<'a> Debug for LweCiphertextView64<'a>

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

Formats the value using the given formatter.

impl<'b> EntitySerializationEngine<LweCiphertextView64<'b>, Vec<u8>> for DefaultSerializationEngine

Description:

Implementation of EntitySerializationEngine for DefaultSerializationEngine that operates on 64 bits integers. It serializes a LWE ciphertext view entity.

fn serialize( &mut self, entity: &LweCiphertextView64<'b>, ) -> Result<Vec<u8>, EntitySerializationError<Self::EngineError>>

Example:

use concrete_core::prelude::Variance;
use concrete_core::prelude::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 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: LweSecretKey64 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let ciphertext = engine.encrypt_lwe_ciphertext(&key, &plaintext, noise)?;

let raw_buffer = engine.consume_retrieve_lwe_ciphertext(ciphertext)?;
let view: LweCiphertextView64 = engine.create_lwe_ciphertext_from(raw_buffer.as_slice())?;

let mut serialization_engine = DefaultSerializationEngine::new(())?;
let serialized = serialization_engine.serialize(&view)?;
let recovered: LweCiphertext64 = serialization_engine.deserialize(serialized.as_slice())?;
let recovered_buffer = engine.consume_retrieve_lwe_ciphertext(recovered)?;
assert_eq!(raw_buffer, recovered_buffer);

unsafe fn serialize_unchecked( &mut self, entity: &LweCiphertextView64<'b>, ) -> Vec<u8>

Unsafely serializes an entity.

impl LweCiphertextCleartextDiscardingMultiplicationEngine<LweCiphertextView64<'_>, Cleartext64, LweCiphertextMutView64<'_>> for DefaultEngine

Description:

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

fn discard_mul_lwe_ciphertext_cleartext( &mut self, output: &mut LweCiphertextMutView64<'_>, input_1: &LweCiphertextView64<'_>, input_2: &Cleartext64, ) -> Result<(), LweCiphertextCleartextDiscardingMultiplicationError<Self::EngineError>>

Example:

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

// 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 50 bits)
let input = 3_u64 << 50;
let cleartext_input = 12_u64;
let noise = Variance(2_f64.powf(-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 cleartext: Cleartext64 = engine.create_cleartext_from(&cleartext_input)?;
let key: LweSecretKey64 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let mut ciphertext_1_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_1: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut ciphertext_1_container[..])?;
engine.discard_encrypt_lwe_ciphertext(&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_from(&raw_ciphertext_1[..])?;

let mut ciphertext_2_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_2: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut ciphertext_2_container[..])?;

engine.discard_mul_lwe_ciphertext_cleartext(&mut ciphertext_2, &ciphertext_1, &cleartext)?;
assert_eq!(ciphertext_2.lwe_dimension(), lwe_dimension);

unsafe fn discard_mul_lwe_ciphertext_cleartext_unchecked( &mut self, output: &mut LweCiphertextMutView64<'_>, input_1: &LweCiphertextView64<'_>, input_2: &Cleartext64, )

Unsafely multiply an LWE ciphertext with a cleartext.

impl<'data> LweCiphertextConsumingRetrievalEngine<LweCiphertextView64<'data>, &'data [u64]> for DefaultEngine

Description:

Implementation of LweCiphertextConsumingRetrievalEngine for DefaultEngine that returns the underlying container of a LweCiphertextView64 consuming it in the process

fn consume_retrieve_lwe_ciphertext( &mut self, ciphertext: LweCiphertextView64<'data>, ) -> Result<&'data [u64], LweCiphertextConsumingRetrievalError<Self::EngineError>>

Example:

use concrete_core::prelude::{LweSize, *};

// Here we create a container outside of the engine
// Note that the size here is just for demonstration purposes and should not be chosen
// without proper security analysis for production
let lwe_size = LweSize(128);
let mut owned_container = vec![0_u64; lwe_size.0];

let slice = &owned_container[..];

// 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 ciphertext_view: LweCiphertextView64 = engine.create_lwe_ciphertext_from(slice)?;
let retrieved_slice = engine.consume_retrieve_lwe_ciphertext(ciphertext_view)?;
assert_eq!(slice, retrieved_slice);

unsafe fn consume_retrieve_lwe_ciphertext_unchecked( &mut self, ciphertext: LweCiphertextView64<'data>, ) -> &'data [u64]

Unsafely retrieves the content of the container from an LWE ciphertext, consuming it in the process.

impl<'data> LweCiphertextCreationEngine<&'data [u64], LweCiphertextView64<'data>> for DefaultEngine

Description:

Implementation of LweCiphertextCreationEngine for DefaultEngine which returns an immutable LweCiphertextView64 that does not own its memory.

fn create_lwe_ciphertext_from( &mut self, container: &'data [u64], ) -> Result<LweCiphertextView64<'data>, LweCiphertextCreationError<Self::EngineError>>

Example:

use concrete_core::prelude::*;

// Here we create a container outside of the engine
// Note that the size here is just for demonstration purposes and should not be chosen
// without proper security analysis for production
let mut owned_container = vec![0_u64; 128];

let slice = &owned_container[..];

// 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 ciphertext_view: LweCiphertextView64 = engine.create_lwe_ciphertext_from(slice)?;

unsafe fn create_lwe_ciphertext_from_unchecked( &mut self, container: &'data [u64], ) -> LweCiphertextView64<'data>

Unsafely creates an LWE ciphertext from an arbitrary container.

impl LweCiphertextDecryptionEngine<LweSecretKey64, LweCiphertextView64<'_>, Plaintext64> for DefaultEngine

Description:

Implementation of LweCiphertextDecryptionEngine for DefaultEngine that operates on an LweCiphertextView64 containing 64 bits integers.

fn decrypt_lwe_ciphertext( &mut self, key: &LweSecretKey64, input: &LweCiphertextView64<'_>, ) -> Result<Plaintext64, LweCiphertextDecryptionError<Self::EngineError>>

Example:

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

// 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 = 3_u64 << 20;
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: LweSecretKey64 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let mut raw_ciphertext = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_view: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut raw_ciphertext[..])?;
engine.discard_encrypt_lwe_ciphertext(&key, &mut ciphertext_view, &plaintext, noise)?;

// Convert MutView to View
let raw_ciphertext = engine.consume_retrieve_lwe_ciphertext(ciphertext_view)?;
let ciphertext_view: LweCiphertextView64 =
    engine.create_lwe_ciphertext_from(&raw_ciphertext[..])?;

let decrypted_plaintext = engine.decrypt_lwe_ciphertext(&key, &ciphertext_view)?;

unsafe fn decrypt_lwe_ciphertext_unchecked( &mut self, key: &LweSecretKey64, input: &LweCiphertextView64<'_>, ) -> Plaintext64

Unsafely decrypts an LWE ciphertext.

impl LweCiphertextDiscardingAdditionEngine<LweCiphertextView64<'_>, LweCiphertextMutView64<'_>> for DefaultEngine

Description:

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

fn discard_add_lwe_ciphertext( &mut self, output: &mut LweCiphertextMutView64<'_>, input_1: &LweCiphertextView64<'_>, input_2: &LweCiphertextView64<'_>, ) -> Result<(), LweCiphertextDiscardingAdditionError<Self::EngineError>>

Example:

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

// 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 50 bits)
let input_1 = 3_u64 << 50;
let input_2 = 7_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: LweSecretKey64 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext_1 = engine.create_plaintext_from(&input_1)?;
let plaintext_2 = engine.create_plaintext_from(&input_2)?;

let mut ciphertext_1_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_1: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut ciphertext_1_container[..])?;
engine.discard_encrypt_lwe_ciphertext(&key, &mut ciphertext_1, &plaintext_1, noise)?;
let mut ciphertext_2_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_2: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut ciphertext_2_container[..])?;
engine.discard_encrypt_lwe_ciphertext(&key, &mut ciphertext_2, &plaintext_2, noise)?;

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

let mut ciphertext_3_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_3: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut ciphertext_3_container[..])?;

engine.discard_add_lwe_ciphertext(&mut ciphertext_3, &ciphertext_1, &ciphertext_2)?;
assert_eq!(ciphertext_3.lwe_dimension(), lwe_dimension);

unsafe fn discard_add_lwe_ciphertext_unchecked( &mut self, output: &mut LweCiphertextMutView64<'_>, input_1: &LweCiphertextView64<'_>, input_2: &LweCiphertextView64<'_>, )

Unsafely adds two LWE ciphertexts.

impl LweCiphertextDiscardingBitExtractEngine<FftFourierLweBootstrapKey64, LweKeyswitchKey64, LweCiphertextView64<'_>, LweCiphertextVectorMutView64<'_>> for FftEngine

Description:

Implementation of LweCiphertextDiscardingBitExtractEngine for FftEngine that operates on views containing 64 bits integers.

fn discard_extract_bits_lwe_ciphertext( &mut self, output: &mut LweCiphertextVectorMutView64<'_>, input: &LweCiphertextView64<'_>, bsk: &FftFourierLweBootstrapKey64, ksk: &LweKeyswitchKey64, extracted_bits_count: ExtractedBitsCount, delta_log: DeltaLog, ) -> Result<(), LweCiphertextDiscardingBitExtractError<Self::EngineError>>

Example

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

// Here a hard-set encoding is applied (shift by 20 bits)
let input = 3_u64 << 20;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let (lwe_dim, glwe_dim, poly_size) = (LweDimension(4), GlweDimension(1), PolynomialSize(512));
let (dec_lc, dec_bl) = (DecompositionLevelCount(3), DecompositionBaseLog(5));
let extracted_bits_count = ExtractedBitsCount(1);
let delta_log = DeltaLog(5);
let noise = Variance(2_f64.powf(-50.));
let large_lwe_dim = LweDimension(glwe_dim.0 * poly_size.0);

// Unix seeder must be given a secret input.
// Here we just give it 0, and rely on /dev/random only for tests.
const UNSAFE_SECRET: u128 = 0;
let mut default_engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let mut fft_engine = FftEngine::new(())?;
let glwe_sk: GlweSecretKey64 =
    default_engine.generate_new_glwe_secret_key(glwe_dim, poly_size)?;
let input_lwe_sk: LweSecretKey64 =
    default_engine.transform_glwe_secret_key_to_lwe_secret_key(glwe_sk.clone())?;
let output_lwe_sk: LweSecretKey64 = default_engine.generate_new_lwe_secret_key(lwe_dim)?;
let bsk: LweBootstrapKey64 = default_engine.generate_new_lwe_bootstrap_key(
    &output_lwe_sk,
    &glwe_sk,
    dec_bl,
    dec_lc,
    noise,
)?;
let ksk: LweKeyswitchKey64 = default_engine.generate_new_lwe_keyswitch_key(
    &input_lwe_sk,
    &output_lwe_sk,
    dec_lc,
    dec_bl,
    noise,
)?;
let bsk: FftFourierLweBootstrapKey64 = fft_engine.convert_lwe_bootstrap_key(&bsk)?;
let plaintext = default_engine.create_plaintext_from(&input)?;

let mut input_ct_container = vec![0u64; input_lwe_sk.lwe_dimension().to_lwe_size().0];
let mut input: LweCiphertextMutView64 =
    default_engine.create_lwe_ciphertext_from(input_ct_container.as_mut_slice())?;

let mut output_ct_vec_container =
    vec![0u64; output_lwe_sk.lwe_dimension().to_lwe_size().0 * extracted_bits_count.0];
let mut output: LweCiphertextVectorMutView64 = default_engine
    .create_lwe_ciphertext_vector_from(
        output_ct_vec_container.as_mut_slice(),
        output_lwe_sk.lwe_dimension().to_lwe_size(),
    )?;

default_engine.discard_encrypt_lwe_ciphertext(&input_lwe_sk, &mut input, &plaintext, noise)?;

let input_slice = default_engine.consume_retrieve_lwe_ciphertext(input)?;
let input: LweCiphertextView64 = default_engine.create_lwe_ciphertext_from(&input_slice[..])?;

fft_engine.discard_extract_bits_lwe_ciphertext(
    &mut output,
    &input,
    &bsk,
    &ksk,
    extracted_bits_count,
    delta_log,
)?;
assert_eq!(output.lwe_dimension(), lwe_dim);
assert_eq!(
    output.lwe_ciphertext_count(),
    LweCiphertextCount(extracted_bits_count.0)
);

unsafe fn discard_extract_bits_lwe_ciphertext_unchecked( &mut self, output: &mut LweCiphertextVectorMutView64<'_>, input: &LweCiphertextView64<'_>, bsk: &FftFourierLweBootstrapKey64, ksk: &LweKeyswitchKey64, extracted_bits_count: ExtractedBitsCount, delta_log: DeltaLog, )

Unsafely extract bits of an LWE ciphertext.

impl LweCiphertextDiscardingBootstrapEngine<FftFourierLweBootstrapKey64, GlweCiphertextView64<'_>, LweCiphertextView64<'_>, LweCiphertextMutView64<'_>> for FftEngine

Description

Implementation of LweCiphertextDiscardingBootstrapEngine for FftEngine that operates on 64 bit integers.

fn discard_bootstrap_lwe_ciphertext( &mut self, output: &mut LweCiphertextMutView64<'_>, input: &LweCiphertextView64<'_>, acc: &GlweCiphertextView64<'_>, bsk: &FftFourierLweBootstrapKey64, ) -> Result<(), LweCiphertextDiscardingBootstrapError<Self::EngineError>>

Example

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

// Here a hard-set encoding is applied (shift by 20 bits)
use concrete_core::backends::fft::engines::FftEngine;
use concrete_core::backends::fft::entities::FftFourierLweBootstrapKey32;
let input = 3_u64 << 20;
// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let (lwe_dim, lwe_dim_output, glwe_dim, poly_size) = (
    LweDimension(4),
    LweDimension(1024),
    GlweDimension(1),
    PolynomialSize(1024),
);
let (dec_lc, dec_bl) = (DecompositionLevelCount(3), DecompositionBaseLog(5));
// A constant function is applied during the bootstrap
let lut = vec![8_u64 << 20; poly_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 default_engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let mut fft_engine = FftEngine::new(())?;
let lwe_sk: LweSecretKey64 = default_engine.generate_new_lwe_secret_key(lwe_dim)?;
let glwe_sk: GlweSecretKey64 =
    default_engine.generate_new_glwe_secret_key(glwe_dim, poly_size)?;
let bsk: LweBootstrapKey64 =
    default_engine.generate_new_lwe_bootstrap_key(&lwe_sk, &glwe_sk, dec_bl, dec_lc, noise)?;
let bsk: FftFourierLweBootstrapKey64 = fft_engine.convert_lwe_bootstrap_key(&bsk)?;
let lwe_sk_output: LweSecretKey64 =
    default_engine.generate_new_lwe_secret_key(lwe_dim_output)?;
let plaintext = default_engine.create_plaintext_from(&input)?;
let plaintext_vector = default_engine.create_plaintext_vector_from(&lut)?;
let acc = default_engine
    .trivially_encrypt_glwe_ciphertext(glwe_dim.to_glwe_size(), &plaintext_vector)?;

// Get the GlweCiphertext as a View
let raw_glwe = default_engine.consume_retrieve_glwe_ciphertext(acc)?;
let acc: GlweCiphertextView64 =
    default_engine.create_glwe_ciphertext_from(&raw_glwe[..], poly_size)?;

let mut raw_input_container = vec![0_u64; lwe_sk.lwe_dimension().to_lwe_size().0];
let input: LweCiphertextMutView64 =
    default_engine.create_lwe_ciphertext_from(&mut raw_input_container[..])?;
let input = default_engine.encrypt_lwe_ciphertext(&lwe_sk, &plaintext, noise)?;

// Convert MutView to View
let raw_input = default_engine.consume_retrieve_lwe_ciphertext(input)?;
let input = default_engine.create_lwe_ciphertext_from(&raw_input[..])?;

let mut raw_output_container = vec![0_u64; lwe_sk_output.lwe_dimension().to_lwe_size().0];
let mut output = default_engine.create_lwe_ciphertext_from(&mut raw_output_container[..])?;

fft_engine.discard_bootstrap_lwe_ciphertext(&mut output, &input, &acc, &bsk)?;
assert_eq!(output.lwe_dimension(), lwe_dim_output);

unsafe fn discard_bootstrap_lwe_ciphertext_unchecked( &mut self, output: &mut LweCiphertextMutView64<'_>, input: &LweCiphertextView64<'_>, acc: &GlweCiphertextView64<'_>, bsk: &FftFourierLweBootstrapKey64, )

Unsafely bootstrap 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_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_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.generate_new_lwe_secret_key(input_lwe_dimension)?;
let output_key: LweSecretKey64 = engine.generate_new_lwe_secret_key(output_lwe_dimension)?;
let keyswitch_key = engine.generate_new_lwe_keyswitch_key(
    &input_key,
    &output_key,
    decomposition_level_count,
    decomposition_base_log,
    noise,
)?;
let plaintext = engine.create_plaintext_from(&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_from(&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_from(&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_from(&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);

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

Unsafely keyswitch an LWE ciphertext.

impl LweCiphertextDiscardingOppositeEngine<LweCiphertextView64<'_>, LweCiphertextMutView64<'_>> for DefaultEngine

Description:

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

fn discard_opp_lwe_ciphertext( &mut self, output: &mut LweCiphertextMutView64<'_>, input: &LweCiphertextView64<'_>, ) -> Result<(), LweCiphertextDiscardingOppositeError<Self::EngineError>>

Example:

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

// 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 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: LweSecretKey64 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let mut ciphertext_1_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_1: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut ciphertext_1_container[..])?;
engine.discard_encrypt_lwe_ciphertext(&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_from(&raw_ciphertext_1[..])?;

let mut ciphertext_2_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_2: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut ciphertext_2_container[..])?;

engine.discard_opp_lwe_ciphertext(&mut ciphertext_2, &ciphertext_1)?;
assert_eq!(ciphertext_2.lwe_dimension(), lwe_dimension);

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

Unsafely computes the opposite of an LWE ciphertext.

impl LweCiphertextEntity for LweCiphertextView64<'_>

fn lwe_dimension(&self) -> LweDimension

Returns the LWE dimension of the ciphertext.

impl LweCiphertextPlaintextDiscardingAdditionEngine<LweCiphertextView64<'_>, Plaintext64, LweCiphertextMutView64<'_>> for DefaultEngine

Description:

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

fn discard_add_lwe_ciphertext_plaintext( &mut self, output: &mut LweCiphertextMutView64<'_>, input_1: &LweCiphertextView64<'_>, input_2: &Plaintext64, ) -> Result<(), LweCiphertextPlaintextDiscardingAdditionError<Self::EngineError>>

Example:

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

// 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 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: LweSecretKey64 = engine.generate_new_lwe_secret_key(lwe_dimension)?;
let plaintext = engine.create_plaintext_from(&input)?;

let mut ciphertext_1_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_1: LweCiphertextMutView64 =
    engine.create_lwe_ciphertext_from(&mut ciphertext_1_container[..])?;
engine.discard_encrypt_lwe_ciphertext(&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_from(&raw_ciphertext_1[..])?;

let mut ciphertext_2_container = vec![0_u64; key.lwe_dimension().to_lwe_size().0];
let mut ciphertext_2 = engine.create_lwe_ciphertext_from(&mut ciphertext_2_container[..])?;

engine.discard_add_lwe_ciphertext_plaintext(&mut ciphertext_2, &ciphertext_1, &plaintext)?;
assert_eq!(ciphertext_2.lwe_dimension(), lwe_dimension);

unsafe fn discard_add_lwe_ciphertext_plaintext_unchecked( &mut self, output: &mut LweCiphertextMutView64<'_>, input_1: &LweCiphertextView64<'_>, input_2: &Plaintext64, )

Unsafely adds a plaintext to an LWE ciphertext.

impl<'a> PartialEq for LweCiphertextView64<'a>

fn eq(&self, other: &LweCiphertextView64<'a>) -> 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<'a> Eq for LweCiphertextView64<'a>

impl<'a> StructuralPartialEq for LweCiphertextView64<'a>