Struct BaseRadixCiphertext 

pub struct BaseRadixCiphertext<Block> { /* private fields */ }

Structure containing a ciphertext in radix decomposition holding an unsigned value.

Implementations

impl BaseRadixCiphertext<Ciphertext>

pub fn block_carries_are_empty(&self) -> bool

pub fn is_trivial(&self) -> bool

pub fn decrypt_trivial<Clear>(&self) -> Result<Clear, NotTrivialCiphertextError>

where Clear: UnsignedNumeric + RecomposableFrom<u64>,

Decrypts a trivial ciphertext

Trivial ciphertexts are ciphertexts which are not encrypted meaning they can be decrypted by any key, or even without a key.

For debugging it can be useful to use trivial ciphertext to speed up execution, and use Self::decrypt_trivial to decrypt temporary values and debug.

Example

use tfhe::integer::{gen_keys_radix, RadixCiphertext};
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

// 8 bits
let (cks, sks) = gen_keys_radix(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128, 4);

let msg = 124u8;
let msg2 = 17u8;

// Trivial encryption
let trivial_ct: RadixCiphertext = sks.create_trivial_radix(msg, 4);
let non_trivial_ct = cks.encrypt(msg2);

let res = trivial_ct.decrypt_trivial();
assert_eq!(Ok(msg), res);

let res = non_trivial_ct.decrypt_trivial::<u8>();
assert!(res.is_err());

// Doing operations that mixes trivial and non trivial
// will always return a non trivial
let ct_res = sks.add_parallelized(&trivial_ct, &non_trivial_ct);
let res = ct_res.decrypt_trivial::<u8>();
assert!(res.is_err());

// Doing operations using only trivial ciphertexts
// will return a trivial
let ct_res = sks.add_parallelized(&trivial_ct, &trivial_ct);
let res = ct_res.decrypt_trivial::<u8>();
assert_eq!(Ok(msg + msg), res);

pub fn re_randomize( &mut self, re_randomization_key: ReRandomizationKey<'_>, seed: ReRandomizationSeed, ) -> Result<()>

impl BaseRadixCiphertext<CompressedCiphertext>

pub fn decompress(&self) -> RadixCiphertext

Trait Implementations

impl<Block: Clone> Clone for BaseRadixCiphertext<Block>

fn clone(&self) -> BaseRadixCiphertext<Block>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Block: Debug> Debug for BaseRadixCiphertext<Block>

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

Formats the value using the given formatter.

impl<'de, Block> Deserialize<'de> for BaseRadixCiphertext<Block>

where Block: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Block: Eq> Eq for BaseRadixCiphertext<Block>

impl<Block> From<Vec<Block>> for BaseRadixCiphertext<Block>

fn from(blocks: Vec<Block>) -> Self

Converts to this type from the input type.

impl<T: ParameterSetConformant<ParameterSet = CiphertextConformanceParams>> ParameterSetConformant for BaseRadixCiphertext<T>

type ParameterSet = RadixCiphertextConformanceParams

fn is_conformant(&self, params: &RadixCiphertextConformanceParams) -> bool

impl<Block: PartialEq> PartialEq for BaseRadixCiphertext<Block>

fn eq(&self, other: &BaseRadixCiphertext<Block>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<Block> Serialize for BaseRadixCiphertext<Block>

where Block: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Scalar> ServerKeyDefaultCMux<&BaseRadixCiphertext<Ciphertext>, Scalar> for ServerKey

where Scalar: DecomposableInto<u64>,

fn if_then_else_parallelized( &self, condition: &BooleanBlock, true_ct: &RadixCiphertext, false_value: Scalar, ) -> Self::Output

FHE “if then else” selection.

Returns a new ciphertext that encrypts the same value as either true_ct or a clear false_value depending on the value of condition:

• If condition == 1, the returned ciphertext will encrypt the same value as true_ct.
• If condition == 0, the returned ciphertext will encrypt the same value as false_value.

To ensure correct results, condition must encrypt either 0 or 1 (e.g result from a comparison).

Note that while the returned ciphertext encrypts the same value as true_ct, it won’t exactly be true_ct.

use tfhe::integer::gen_keys_radix;
use tfhe::integer::prelude::*;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

// We have 4 * 2 = 8 bits of message
let size = 4;
let (cks, sks) = gen_keys_radix(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128, size);

let a = 126i8;
let b = -55i8;

let ct_a = cks.encrypt_signed(a);

let condition = sks.scalar_lt_parallelized(&ct_a, 66);

let ct_res = sks.if_then_else_parallelized(&condition, &ct_a, b);

// Decrypt:
let dec: i8 = cks.decrypt_signed(&ct_res);
assert_eq!(if a < 66 { a } else { b }, dec);
assert_ne!(ct_a, ct_res);

type Output = BaseRadixCiphertext<Ciphertext>

fn flip_parallelized( &self, condition: &BooleanBlock, true_ct: &RadixCiphertext, false_ct: Scalar, ) -> (Self::Output, Self::Output)

fn select_parallelized( &self, condition: &BooleanBlock, ct_when_true: TrueCt, ct_when_false: FalseCt, ) -> Self::Output

fn cmux_parallelized( &self, condition: &BooleanBlock, true_ct: TrueCt, false_ct: FalseCt, ) -> Self::Output

impl<Scalar> ServerKeyDefaultCMux<Scalar, &BaseRadixCiphertext<Ciphertext>> for ServerKey

where Scalar: DecomposableInto<u64>,

fn if_then_else_parallelized( &self, condition: &BooleanBlock, true_value: Scalar, false_ct: &RadixCiphertext, ) -> Self::Output

FHE “if then else” selection.

Returns a new ciphertext that encrypts the same value as either true_value or a false_ct depending on the value of condition:

• If condition == 1, the returned ciphertext will encrypt the same value as true_value.
• If condition == 0, the returned ciphertext will encrypt the same value as false_ct.

To ensure correct results, condition must encrypt either 0 or 1 (e.g result from a comparison).

Note that while the returned ciphertext encrypts the same value as true_ct, it won’t exactly be true_ct.

use tfhe::integer::gen_keys_radix;
use tfhe::integer::prelude::*;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

// We have 4 * 2 = 8 bits of message
let size = 4;
let (cks, sks) = gen_keys_radix(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128, size);

let a = 126u8;
let b = 55u8;

let ct_b = cks.encrypt(b);

let condition = sks.scalar_lt_parallelized(&ct_b, 66);

let ct_res = sks.if_then_else_parallelized(&condition, a, &ct_b);

// Decrypt:
let dec: u8 = cks.decrypt(&ct_res);
assert_eq!(if b < 66 { a } else { b }, dec);
assert_ne!(ct_b, ct_res);

type Output = BaseRadixCiphertext<Ciphertext>

fn flip_parallelized( &self, condition: &BooleanBlock, true_value: Scalar, false_ct: &RadixCiphertext, ) -> (Self::Output, Self::Output)

fn select_parallelized( &self, condition: &BooleanBlock, ct_when_true: TrueCt, ct_when_false: FalseCt, ) -> Self::Output

fn cmux_parallelized( &self, condition: &BooleanBlock, true_ct: TrueCt, false_ct: FalseCt, ) -> Self::Output

impl<Block: PartialEq> StructuralPartialEq for BaseRadixCiphertext<Block>

impl<Id> TryFrom<BaseRadixCiphertext<Ciphertext>> for FheUint<Id>

where Id: FheUintId,

type Error = GenericIntegerBlockError

The type returned in the event of a conversion error.

fn try_from(other: RadixCiphertext) -> Result<Self, GenericIntegerBlockError>

Performs the conversion.

impl<Block> Unversionize for BaseRadixCiphertext<Block>

where BaseRadixCiphertextVersions<Block>: VersionsDispatch<Self>,

fn unversionize( versioned: Self::VersionedOwned, ) -> Result<Self, UnversionizeError>

Creates an object from a versioned enum, and eventually upgrades from previous variants.

impl<Block> UnversionizeVec for BaseRadixCiphertext<Block>

where BaseRadixCiphertextVersions<Block>: VersionsDispatch<Self>,

fn unversionize_vec( versioned: Self::VersionedVec, ) -> Result<Vec<Self>, UnversionizeError>

impl<Block> Version for BaseRadixCiphertext<Block>

where Vec<Block>: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = BaseRadixCiphertextVersion<'vers, Block> where Block: 'vers

type Owned = BaseRadixCiphertextVersionOwned<Block>

impl<Block> Versionize for BaseRadixCiphertext<Block>

where BaseRadixCiphertextVersions<Block>: VersionsDispatch<Self>,

type Versioned<'vers> = <BaseRadixCiphertextVersions<Block> as VersionsDispatch<BaseRadixCiphertext<Block>>>::Ref<'vers> where Block: 'vers

The equivalent versioned type. It should have a variant for each version. It may own the underlying data or only hold a read-only reference to it.

fn versionize(&self) -> Self::Versioned<'_>

Wraps the object into a versioned enum with a variant for each version. This will use references on the underlying types if possible.

impl<Block> VersionizeOwned for BaseRadixCiphertext<Block>

where BaseRadixCiphertextVersions<Block>: VersionsDispatch<Self>,

type VersionedOwned = <BaseRadixCiphertextVersions<Block> as VersionsDispatch<BaseRadixCiphertext<Block>>>::Owned

fn versionize_owned(self) -> Self::VersionedOwned

Wraps the object into a versioned enum with a variant for each version. This will clone the underlying types.

impl<Block> VersionizeSlice for BaseRadixCiphertext<Block>

where BaseRadixCiphertextVersions<Block>: VersionsDispatch<Self>,

type VersionedSlice<'vers> = Vec<<BaseRadixCiphertext<Block> as Versionize>::Versioned<'vers>> where Block: 'vers

fn versionize_slice(slice: &[Self]) -> Self::VersionedSlice<'_>

impl<Block> VersionizeVec for BaseRadixCiphertext<Block>

where BaseRadixCiphertextVersions<Block>: VersionsDispatch<Self>,

type VersionedVec = Vec<<BaseRadixCiphertext<Block> as VersionizeOwned>::VersionedOwned>

fn versionize_vec(vec: Vec<Self>) -> Self::VersionedVec

impl<Block> VersionsDispatch<BaseRadixCiphertext<Block>> for BaseRadixCiphertextVersions<Block>

where BaseRadixCiphertext<Block>: Version,

type Ref<'vers> = BaseRadixCiphertextVersionsDispatch<'vers, Block> where Block: 'vers

type Owned = BaseRadixCiphertextVersionsDispatchOwned<Block>