github/tfhe-rs
1
1
Fork 0
mirror of https://github.com/zama-ai/tfhe-rs.git synced 2026-01-08 22:28:01 -05:00
Code Issues Packages Projects Releases Wiki Activity

chore(all): fix doctests clippy lints

Browse Source
This commit is contained in:
Mayeul@Zama
2024-06-21 17:04:13 +02:00
committed by Arthur Meyre
parent a153ea98ae
commit cc8f2cb4dc
81 changed files with 305 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tfhe/docs/fundamentals/serialization.md
View File

@@ -22,7 +22,6 @@ bincode = "1.3.3"
```rust
// main.rs
use bincode;
use std::io::Cursor;
use tfhe::{ConfigBuilder, ServerKey, generate_keys, set_server_key, FheUint8};
use tfhe::prelude::*;

12
tfhe/docs/getting_started/operations.md
View File

@@ -97,10 +97,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut d = FheInt8::try_encrypt(clear_d, &keys)?;
a = a * &b; // Clear equivalent computations: 15 * 27 mod 256 = 149
a *= &b; // Clear equivalent computations: 15 * 27 mod 256 = 149
b = &b + &c; // Clear equivalent computations: 27 + 43 mod 256 = 70
b = b - 76u8; // Clear equivalent computations: 70 - 76 mod 256 = 250
d = d - 13i8; // Clear equivalent computations: -87 - 13 = 100 in [-128, 128[
b -= 76u8; // Clear equivalent computations: 70 - 76 mod 256 = 250
d -= 13i8; // Clear equivalent computations: -87 - 13 = 100 in [-128, 128[
let dec_a: u8 = a.decrypt(&keys);
let dec_b: u8 = b.decrypt(&keys);
@@ -146,9 +146,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut a = FheUint8::try_encrypt(clear_a, &keys)?;
let mut b = FheUint8::try_encrypt(clear_b, &keys)?;
a = a ^ &b;
b = b ^ &a;
a = a ^ &b;
a ^= &b;
b ^= &a;
a ^= &b;
let dec_a: u8 = a.decrypt(&keys);
let dec_b: u8 = b.decrypt(&keys);

1
tfhe/docs/guides/data_versioning.md
View File

@@ -24,7 +24,6 @@ bincode = "1.3.3"
```rust
// main.rs
use bincode;
use std::io::Cursor;
use tfhe::prelude::{FheDecrypt, FheEncrypt};
use tfhe::{ClientKey, ConfigBuilder, FheUint8};

2
tfhe/docs/guides/overflow_operations.md
View File

@@ -38,7 +38,7 @@ assert_eq!(
overflowed.decrypt(&client_key),
u16::MAX.overflowing_add(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);
assert!(overflowed.decrypt(&client_key));
```
The following tables show the current benchmarks result.

4
tfhe/docs/guides/zk-pok.md
View File

@@ -43,7 +43,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
set_server_key(server_key);
// Verify the ciphertexts
let mut expander = proven_compact_list.verify_and_expand(&public_zk_params, &public_key)?;
let mut expander = proven_compact_list.verify_and_expand(public_zk_params, &public_key)?;
let a: tfhe::FheUint64 = expander.get(0).unwrap()?;
let b: tfhe::FheUint64 = expander.get(1).unwrap()?;
@@ -115,7 +115,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
set_server_key(server_key);
// Verify the ciphertexts
let mut expander = proven_compact_list.verify_and_expand(&public_zk_params, &public_key)?;
let mut expander = proven_compact_list.verify_and_expand(public_zk_params, &public_key)?;
let a: tfhe::FheUint64 = expander.get(0).unwrap()?;
let b: tfhe::FheUint64 = expander.get(1).unwrap()?;

2
tfhe/docs/references/fine-grained-apis/boolean/README.md
View File

@@ -204,6 +204,6 @@ fn main() {
let output = client_key.decrypt(&output);
// And check that the result is the expected one:
assert_eq!(output, true);
assert!(output);
}
```

2
tfhe/docs/references/fine-grained-apis/boolean/operations.md
View File

@@ -20,7 +20,7 @@ fn main() {
// We use the client key to decrypt the output of the circuit:
let output = client_key.decrypt(&ct_not);
assert_eq!(output, false);
assert!(!output);
}
```

2
tfhe/docs/references/fine-grained-apis/boolean/serialization.md
View File

@@ -58,6 +58,6 @@ fn main() {
let ct_1 = client_key.encrypt(false);
// We check for equality:
assert_eq!(false, loaded_client_key.decrypt(&ct_1));
assert!(!loaded_client_key.decrypt(&ct_1));
}
```

12
tfhe/docs/references/fine-grained-apis/integer/operations.md
View File

@@ -132,7 +132,7 @@ fn main() {
// We use the client key to decrypt the output of the circuit:
let output: u64 = client_key.decrypt(&ct_1);
// The carry buffer has been overflowed, the result is not correct
assert_ne!(output, ((msg1 * scalar as u64 - msg2) + msg3) % modulus as u64);
assert_ne!(output, ((msg1 * scalar - msg2) + msg3) % modulus);
}
```
@@ -171,7 +171,7 @@ fn main() {
// We use the client key to decrypt the output of the circuit:
// Only the scalar multiplication could be done
let output: u64 = client_key.decrypt(&ct_1);
assert_eq!(output, ((msg1 * scalar) - msg2) % modulus as u64);
assert_eq!(output, ((msg1 * scalar) - msg2) % modulus);
}
```
@@ -208,7 +208,7 @@ fn main() {
// We use the client key to decrypt the output of the circuit:
let output: u64 = client_key.decrypt(&ct_1);
assert_eq!(output, ((msg1 * scalar as u64 - msg2) + msg3) % modulus as u64);
assert_eq!(output, ((msg1 * scalar - msg2) + msg3) % modulus);
}
```
@@ -249,12 +249,12 @@ fn main() {
server_key.scalar_mul_assign_parallelized(&mut ct_1, scalar);
server_key.sub_assign_parallelized(&mut ct_1, &mut ct_2);
server_key.sub_assign_parallelized(&mut ct_1, &ct_2);
server_key.add_assign_parallelized(&mut ct_1, &mut ct_3);
server_key.add_assign_parallelized(&mut ct_1, &ct_3);
// We use the client key to decrypt the output of the circuit:
let output: u64 = client_key.decrypt(&ct_1);
assert_eq!(output, ((msg1 * scalar as u64 - msg2) + msg3) % modulus as u64);
assert_eq!(output, ((msg1 * scalar - msg2) + msg3) % modulus);
}
```

1
tfhe/docs/references/fine-grained-apis/integer/serialization.md
View File

@@ -17,7 +17,6 @@ bincode = "1.3.3"
```rust
// main.rs
use bincode;
use std::io::Cursor;
use tfhe::integer::{gen_keys_radix, ServerKey, RadixCiphertext};
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS;

2
tfhe/docs/references/fine-grained-apis/quick_start.md
View File

@@ -91,7 +91,7 @@ fn main() {
// We use the client key to decrypt the output of the circuit:
let output = client_key.decrypt(&ct_6);
assert_eq!(output, true);
assert!(output);
}
```

4
tfhe/docs/references/fine-grained-apis/shortint/operations.md
View File

@@ -175,8 +175,8 @@ fn main() {
let mut ct_2 = client_key.encrypt(msg2);
server_key.scalar_mul_assign(&mut ct_1, scalar);
server_key.sub_assign(&mut ct_1, &mut ct_2);
server_key.mul_lsb_assign(&mut ct_1, &mut ct_2);
server_key.sub_assign(&mut ct_1, &ct_2);
server_key.mul_lsb_assign(&mut ct_1, &ct_2);
// We use the client key to decrypt the output of the circuit:
let output = client_key.decrypt(&ct_1);

1
tfhe/docs/references/fine-grained-apis/shortint/serialization.md
View File

@@ -17,7 +17,6 @@ bincode = "1.3.3"
```rust
// main.rs
use bincode;
use std::io::Cursor;
use tfhe::shortint::prelude::*;

2
tfhe/docs/tutorials/ascii_fhe_string.md
View File

@@ -92,7 +92,7 @@ fn to_lower(c: &FheUint8) -> FheUint8 {
impl FheAsciiString {
fn encrypt(string: &str, client_key: &ClientKey) -> Self {
assert!(
string.chars().all(|char| char.is_ascii()),
string.is_ascii(),
"The input string must only contain ascii letters"
);

4
tfhe/docs/tutorials/parity_bit.md
View File

@@ -127,7 +127,7 @@ fn main() {
set_server_key(server_key);
let clear_bits = [0, 1, 0, 0, 0, 1, 1].map(|b| (b != 0) as bool);
let clear_bits = [0, 1, 0, 0, 0, 1, 1].map(|b| (b != 0));
let fhe_bits = clear_bits
.iter()
@@ -338,7 +338,7 @@ fn main() {
set_server_key(server_key);
let clear_bits = [0, 1, 0, 0, 0, 1, 1].map(|b| (b != 0) as bool);
let clear_bits = [0, 1, 0, 0, 0, 1, 1].map(|b| (b != 0));
let fhe_bits = clear_bits
.iter()

6
tfhe/src/boolean/client_key/mod.rs
View File

@@ -77,7 +77,7 @@ impl ClientKey {
///
/// // Decryption:
/// let dec = cks.decrypt(&ct);
/// assert_eq!(true, dec);
/// assert!(dec);
/// ```
pub fn encrypt(&self, message: bool) -> Ciphertext {
BooleanEngine::with_thread_local_mut(|engine| engine.encrypt(message, self))
@@ -100,7 +100,7 @@ impl ClientKey {
///
/// // Decryption:
/// let dec = cks.decrypt(&ct);
/// assert_eq!(true, dec);
/// assert!(dec);
/// ```
pub fn encrypt_compressed(&self, message: bool) -> CompressedCiphertext {
BooleanEngine::with_thread_local_mut(|engine| engine.encrypt_compressed(message, self))
@@ -121,7 +121,7 @@ impl ClientKey {
///
/// // Decryption:
/// let dec = cks.decrypt(&ct);
/// assert_eq!(true, dec);
/// assert!(dec);
/// ```
pub fn decrypt(&self, ct: &Ciphertext) -> bool {
BooleanEngine::with_thread_local_mut(|engine| engine.decrypt(ct, self))

6
tfhe/src/boolean/mod.rs
View File

@@ -34,19 +34,19 @@
//!
//! // We use the client key to decrypt the output of the circuit:
//! let output_1 = client_key.decrypt(&ct_6);
//! assert_eq!(output_1, true);
//! assert!(output_1);
//!
//! // It is possible to compute gates with one input unencrypted
//! let ct_7 = server_key.and(&ct_6, true);
//! let output_2 = client_key.decrypt(&ct_7);
//! assert_eq!(output_2, true);
//! assert!(output_2);
//!
//! // It is possible to trivially encrypt on the server side
//! // i.e. to not encrypt but still generate a compatible Ciphertext
//! let ct_8 = server_key.trivial_encrypt(false);
//! let ct_9 = server_key.mux(&ct_7, &ct_3, &ct_8);
//! let output_3 = client_key.decrypt(&ct_9);
//! assert_eq!(output_3, true);
//! assert!(output_3);
//! ```
use crate::boolean::client_key::ClientKey;

2
tfhe/src/boolean/public_key/compressed.rs
View File

@@ -121,7 +121,7 @@ impl CompressedPublicKey {
///
/// // Decryption:
/// let dec = cks.decrypt(&ct_res);
/// assert_eq!(false, dec);
/// assert!(!dec);
/// ```
pub fn encrypt(&self, message: bool) -> Ciphertext {
BooleanEngine::with_thread_local_mut(|engine| {

2
tfhe/src/boolean/public_key/standard.rs
View File

@@ -35,7 +35,7 @@ impl PublicKey {
///
/// // Decryption:
/// let dec = cks.decrypt(&ct_res);
/// assert_eq!(false, dec);
/// assert!(!dec);
/// ```
pub fn encrypt(&self, message: bool) -> Ciphertext {
BooleanEngine::with_thread_local_mut(|engine| engine.encrypt_with_public_key(message, self))

10
tfhe/src/core_crypto/algorithms/glwe_encryption.rs
View File

@@ -227,7 +227,7 @@ pub fn fill_glwe_mask_and_body_for_encryption_assign_non_native_mod<
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///
@@ -564,7 +564,7 @@ pub fn fill_glwe_mask_and_body_for_encryption_other_mod<
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///
@@ -695,7 +695,7 @@ pub fn encrypt_glwe_ciphertext<Scalar, NoiseDistribution, KeyCont, InputCont, Ou
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///
@@ -1268,7 +1268,7 @@ pub fn encrypt_seeded_glwe_ciphertext_with_existing_generator<
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///
@@ -1461,7 +1461,7 @@ pub fn encrypt_seeded_glwe_ciphertext_list_with_existing_generator<
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///

8
tfhe/src/core_crypto/algorithms/glwe_linear_algebra.rs
View File

@@ -363,7 +363,7 @@ pub fn glwe_ciphertext_plaintext_list_add_assign<Scalar, InCont, PlainCont>(
/// .for_each(|x| *x.0 = decomposer.closest_representable(*x.0) >> 60);
///
/// // Check we recovered the expected result
/// assert!(output_plaintext_list.iter().all(|x| *x.0 == msg - msg));
/// assert!(output_plaintext_list.iter().all(|x| *x.0 == 0));
/// ```
pub fn glwe_ciphertext_plaintext_list_sub_assign<Scalar, InCont, PlainCont>(
lhs: &mut GlweCiphertext<InCont>,
@@ -547,7 +547,7 @@ pub fn glwe_ciphertext_plaintext_add_assign<Scalar, InCont>(
/// .for_each(|x| *x.0 = decomposer.closest_representable(*x.0) >> 60);
///
/// // Check we recovered the expected result
/// assert!(output_plaintext_list.iter().all(|x| *x.0 == msg - msg));
/// assert!(output_plaintext_list.iter().all(|x| *x.0 == 0));
/// ```
pub fn glwe_ciphertext_plaintext_sub_assign<Scalar, InCont>(
lhs: &mut GlweCiphertext<InCont>,
@@ -901,7 +901,7 @@ pub fn glwe_ciphertext_cleartext_mul<Scalar, InputCont, OutputCont>(
/// .for_each(|x| *x.0 = decomposer.closest_representable(*x.0) >> 60);
///
/// // Check we recovered the expected result
/// assert!(output_plaintext_list.iter().all(|x| *x.0 == msg - msg));
/// assert!(output_plaintext_list.iter().all(|x| *x.0 == 0));
/// ```
pub fn glwe_ciphertext_sub_assign<Scalar, LhsCont, RhsCont>(
lhs: &mut GlweCiphertext<LhsCont>,
@@ -996,7 +996,7 @@ pub fn glwe_ciphertext_sub_assign<Scalar, LhsCont, RhsCont>(
/// .for_each(|x| *x.0 = decomposer.closest_representable(*x.0) >> 60);
///
/// // Check we recovered the expected result
/// assert!(output_plaintext_list.iter().all(|x| *x.0 == msg - msg));
/// assert!(output_plaintext_list.iter().all(|x| *x.0 == 0));
/// ```
pub fn glwe_ciphertext_sub<Scalar, OutputCont, LhsCont, RhsCont>(
output: &mut GlweCiphertext<OutputCont>,

2
tfhe/src/core_crypto/algorithms/glwe_secret_key_generation.rs
View File

@@ -56,7 +56,7 @@ where
/// // Check all coefficients are not zero as we just generated a new key
/// // Note probability of this assert failing is (1/2)^polynomial_size or ~5.6 * 10^-309 for a
/// // polynomial size of 1024.
/// assert!(glwe_secret_key.as_ref().iter().all(|&elt| elt == 0) == false);
/// assert!(!glwe_secret_key.as_ref().iter().all(|&elt| elt == 0));
/// ```
pub fn generate_binary_glwe_secret_key<Scalar, InCont, Gen>(
glwe_secret_key: &mut GlweSecretKey<InCont>,

2
tfhe/src/core_crypto/algorithms/lwe_bootstrap_key_generation.rs
View File

@@ -245,7 +245,7 @@ where
/// &mut encryption_generator,
/// );
///
/// assert!(bsk.as_ref().iter().all(|&x| x == 0) == false);
/// assert!(!bsk.as_ref().iter().all(|&x| x == 0));
/// ```
pub fn par_generate_lwe_bootstrap_key<
Scalar,

8
tfhe/src/core_crypto/algorithms/lwe_encryption.rs
View File

@@ -680,7 +680,7 @@ where
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///
@@ -791,7 +791,7 @@ pub fn encrypt_lwe_ciphertext_list<Scalar, NoiseDistribution, KeyCont, OutputCon
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///
@@ -1253,7 +1253,7 @@ pub fn encrypt_seeded_lwe_ciphertext_list_with_existing_generator<
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///
@@ -1424,7 +1424,7 @@ pub fn par_encrypt_seeded_lwe_ciphertext_list_with_existing_generator<
/// // Get the raw vector
/// let mut cleartext_list = output_plaintext_list.into_container();
/// // Remove the encoding
/// cleartext_list.iter_mut().for_each(|elt| *elt = *elt >> 60);
/// cleartext_list.iter_mut().for_each(|elt| *elt >>= 60);
/// // Get the list immutably
/// let cleartext_list = cleartext_list;
///

4
tfhe/src/core_crypto/algorithms/lwe_keyswitch_key_generation.rs
View File

@@ -62,7 +62,7 @@ use crate::core_crypto::entities::*;
/// &mut encryption_generator,
/// );
///
/// assert!(ksk.as_ref().iter().all(|&x| x == 0) == false);
/// assert!(!ksk.as_ref().iter().all(|&x| x == 0));
/// ```
pub fn generate_lwe_keyswitch_key<
Scalar,
@@ -355,7 +355,7 @@ where
/// seeder,
/// );
///
/// assert!(ksk.as_ref().iter().all(|&x| x == 0) == false);
/// assert!(!ksk.as_ref().iter().all(|&x| x == 0));
/// ```
pub fn generate_seeded_lwe_keyswitch_key<
Scalar,

4
tfhe/src/core_crypto/algorithms/lwe_linear_algebra.rs
View File

@@ -382,7 +382,7 @@ pub fn lwe_ciphertext_plaintext_add_assign_other_mod<Scalar, InCont>(
/// let cleartext = rounded >> 60;
///
/// // Check we recovered the expected result
/// assert_eq!(cleartext, msg - msg);
/// assert_eq!(cleartext, 0);
/// ```
pub fn lwe_ciphertext_plaintext_sub_assign<Scalar, InCont>(
lhs: &mut LweCiphertext<InCont>,
@@ -705,7 +705,7 @@ pub fn lwe_ciphertext_cleartext_mul<Scalar, InputCont, OutputCont>(
/// let cleartext = rounded >> 60;
///
/// // Check we recovered the expected result
/// assert_eq!(cleartext, msg - msg);
/// assert_eq!(cleartext, 0);
/// ```
pub fn lwe_ciphertext_sub_assign<Scalar, LhsCont, RhsCont>(
lhs: &mut LweCiphertext<LhsCont>,

12
tfhe/src/core_crypto/algorithms/lwe_packing_keyswitch.rs
View File

@@ -290,9 +290,7 @@ pub fn keyswitch_lwe_ciphertext_into_glwe_ciphertext<Scalar, KeyCont, InputCont,
/// decrypted_plaintext_list
/// .iter_mut()
/// .for_each(|x| *x.0 = decomposer.closest_representable(*x.0) >> 60);
/// input_plaintext_list
/// .iter_mut()
/// .for_each(|x| *x.0 = *x.0 >> 60);
/// input_plaintext_list.iter_mut().for_each(|x| *x.0 >>= 60);
///
/// // Check we recovered the original message
/// assert_eq!(input_plaintext_list, decrypted_plaintext_list);
@@ -486,9 +484,7 @@ pub fn keyswitch_lwe_ciphertext_list_and_pack_in_glwe_ciphertext<
/// decrypted_plaintext_list
/// .iter_mut()
/// .for_each(|x| *x.0 = decomposer.closest_representable(*x.0) >> 60);
/// input_plaintext_list
/// .iter_mut()
/// .for_each(|x| *x.0 = *x.0 >> 60);
/// input_plaintext_list.iter_mut().for_each(|x| *x.0 >>= 60);
///
/// // Check we recovered the original message
/// assert_eq!(input_plaintext_list, decrypted_plaintext_list);
@@ -625,9 +621,7 @@ pub fn par_keyswitch_lwe_ciphertext_list_and_pack_in_glwe_ciphertext<
/// decrypted_plaintext_list
/// .iter_mut()
/// .for_each(|x| *x.0 = decomposer.closest_representable(*x.0) >> 60);
/// input_plaintext_list
/// .iter_mut()
/// .for_each(|x| *x.0 = *x.0 >> 60);
/// input_plaintext_list.iter_mut().for_each(|x| *x.0 >>= 60);
///
/// // Check we recovered the original message
/// assert_eq!(input_plaintext_list, decrypted_plaintext_list);

4
tfhe/src/core_crypto/algorithms/lwe_packing_keyswitch_key_generation.rs
View File

@@ -69,7 +69,7 @@ use crate::core_crypto::entities::{
/// &mut encryption_generator,
/// );
///
/// assert!(pksk.as_ref().iter().all(|&x| x == 0) == false);
/// assert!(!pksk.as_ref().iter().all(|&x| x == 0));
/// ```
pub fn generate_lwe_packing_keyswitch_key<
Scalar,
@@ -261,7 +261,7 @@ where
/// seeder,
/// );
///
/// assert!(seeded_pksk.as_ref().iter().all(|&x| x == 0) == false);
/// assert!(!seeded_pksk.as_ref().iter().all(|&x| x == 0));
/// ```
pub fn generate_seeded_lwe_packing_keyswitch_key<
Scalar,

2
tfhe/src/core_crypto/algorithms/lwe_secret_key_generation.rs
View File

@@ -51,7 +51,7 @@ where
/// // Check all coefficients are not zero as we just generated a new key
/// // Note probability of this assert failing is (1/2)^lwe_dimension or ~4.3 * 10^-224 for an LWE
/// // dimension of 742.
/// assert!(lwe_secret_key.as_ref().iter().all(|&elt| elt == 0) == false);
/// assert!(!lwe_secret_key.as_ref().iter().all(|&elt| elt == 0));
/// ```
pub fn generate_binary_lwe_secret_key<Scalar, InCont, Gen>(
lwe_secret_key: &mut LweSecretKey<InCont>,

5
tfhe/src/core_crypto/algorithms/polynomial_algorithms.rs
View File

@@ -694,10 +694,9 @@ pub(crate) fn polynomial_wrapping_monic_monomial_mul_and_subtract<Scalar, Output
/// use tfhe::core_crypto::algorithms::polynomial_algorithms::*;
/// use tfhe::core_crypto::commons::parameters::*;
/// use tfhe::core_crypto::entities::*;
/// let poly_list =
/// PolynomialList::from_container(vec![100 as u8, 20, 3, 4, 5, 6], PolynomialSize(3));
/// let poly_list = PolynomialList::from_container(vec![100_u8, 20, 3, 4, 5, 6], PolynomialSize(3));
/// let bin_poly_list = PolynomialList::from_container(vec![0, 1, 1, 1, 0, 0], PolynomialSize(3));
/// let mut output = Polynomial::new(250 as u8, PolynomialSize(3));
/// let mut output = Polynomial::new(250_u8, PolynomialSize(3));
/// polynomial_wrapping_sub_multisum_assign(&mut output, &poly_list, &bin_poly_list);
/// assert_eq!(output.as_ref(), &[13, 148, 124]);
/// ```

4
tfhe/src/core_crypto/commons/math/random/generator.rs
View File

@@ -608,12 +608,12 @@ impl<G: ByteRandomGenerator> RandomGenerator<G> {
/// use tfhe::core_crypto::commons::math::random::RandomGenerator;
/// let mut generator = RandomGenerator::<SoftwareRandomGenerator>::new(Seed(0));
/// // for f32
/// let (g1, g2): (f32, f32) = generator.random_gaussian(0. as f32, 1. as f32);
/// let (g1, g2): (f32, f32) = generator.random_gaussian(0_f32, 1_f32);
/// // check that both samples are in 6 sigmas.
/// assert!(g1.abs() <= 6.);
/// assert!(g2.abs() <= 6.);
/// // for f64
/// let (g1, g2): (f64, f64) = generator.random_gaussian(0. as f64, 1. as f64);
/// let (g1, g2): (f64, f64) = generator.random_gaussian(0_f64, 1_f64);
/// // check that both samples are in 6 sigmas.
/// assert!(g1.abs() <= 6.);
/// assert!(g2.abs() <= 6.);

2
tfhe/src/core_crypto/entities/glwe_secret_key.rs
View File

@@ -213,7 +213,7 @@ where
/// // Check all coefficients are not zero as we just generated a new key
/// // Note probability of this assert failing is (1/2)^polynomial_size or ~5.6 * 10^-309 for a
/// // polynomial size of 1024.
/// assert!(glwe_secret_key.as_ref().iter().all(|&elt| elt == 0) == false);
/// assert!(!glwe_secret_key.as_ref().iter().all(|&elt| elt == 0));
/// ```
pub fn generate_new_binary<Gen>(
glwe_dimension: GlweDimension,

2
tfhe/src/core_crypto/entities/lwe_secret_key.rs
View File

@@ -158,7 +158,7 @@ where
/// // Check all coefficients are not zero as we just generated a new key
/// // Note probability of this assert failing is (1/2)^lwe_dimension or ~4.3 * 10^-224 for an
/// // LWE dimension of 742.
/// assert!(lwe_secret_key.as_ref().iter().all(|&elt| elt == 0) == false);
/// assert!(!lwe_secret_key.as_ref().iter().all(|&elt| elt == 0));
/// ```
pub fn generate_new_binary<Gen>(
lwe_dimension: LweDimension,

26
tfhe/src/high_level_api/booleans/base.rs
View File

@@ -44,7 +44,7 @@ use tfhe_versionable::Versionize;
/// let fhe_result = ttrue & ffalse;
///
/// let clear_result = fhe_result.decrypt(&client_key);
/// assert_eq!(clear_result, false);
/// assert!(!clear_result);
/// ```
#[derive(Clone, Serialize, Deserialize, Versionize)]
#[versionize(FheBoolVersions)]
@@ -141,7 +141,7 @@ impl FheBool {
///
/// // We cannot trivial decrypt
/// let result: Result<bool, _> = non_trivial.try_decrypt_trivial();
/// matches!(result, Err(_));
/// assert!(result.is_err());
/// ```
pub fn try_decrypt_trivial(&self) -> Result<bool, NotTrivialCiphertextError> {
self.ciphertext.on_cpu().decrypt_trivial()
@@ -270,7 +270,7 @@ where
/// let result = a.eq(&b);
///
/// let decrypted = result.decrypt(&client_key);
/// assert_eq!(decrypted, true == false);
/// assert!(!decrypted);
/// ```
fn eq(&self, other: B) -> Self {
let ciphertext = global_state::with_internal_keys(|key| match key {
@@ -353,7 +353,7 @@ impl FheEq<bool> for FheBool {
/// let result = a.eq(false);
///
/// let decrypted = result.decrypt(&client_key);
/// assert_eq!(decrypted, true == false);
/// assert!(!decrypted);
/// ```
fn eq(&self, other: bool) -> FheBool {
let ciphertext = global_state::with_internal_keys(|key| match key {
@@ -438,7 +438,7 @@ where
///
/// let result = a & &b;
/// let result = result.decrypt(&client_key);
/// assert_eq!(result, true & true);
/// assert!(result);
/// ```
fn bitand(self, rhs: B) -> Self::Output {
BitAnd::bitand(&self, rhs)
@@ -466,7 +466,7 @@ where
///
/// let result = &a & &b;
/// let result = result.decrypt(&client_key);
/// assert_eq!(result, true & true);
/// assert!(result);
/// ```
fn bitand(self, rhs: B) -> Self::Output {
let ciphertext = global_state::with_internal_keys(|key| match key {
@@ -592,7 +592,7 @@ where
///
/// let result = a ^ &b;
/// let result = result.decrypt(&client_key);
/// assert_eq!(result, true ^ true);
/// assert!(!result);
/// ```
fn bitxor(self, rhs: B) -> Self::Output {
BitXor::bitxor(&self, rhs)
@@ -621,7 +621,7 @@ where
///
/// let result = &a ^ &b;
/// let result = result.decrypt(&client_key);
/// assert_eq!(result, true ^ true);
/// assert!(!result);
/// ```
fn bitxor(self, rhs: B) -> Self::Output {
let ciphertext = global_state::with_internal_keys(|key| match key {
@@ -1029,7 +1029,7 @@ where
///
/// a &= b;
/// let result = a.decrypt(&client_key);
/// assert_eq!(result, true & true);
/// assert!(result);
/// ```
fn bitand_assign(&mut self, rhs: B) {
let rhs = rhs.borrow();
@@ -1072,7 +1072,7 @@ where
///
/// a |= &b;
/// let result = a.decrypt(&client_key);
/// assert_eq!(result, true | true);
/// assert!(result);
/// ```
fn bitor_assign(&mut self, rhs: B) {
let rhs = rhs.borrow();
@@ -1115,7 +1115,7 @@ where
///
/// a ^= &b;
/// let result = a.decrypt(&client_key);
/// assert_eq!(result, true ^ true);
/// assert!(!result);
/// ```
fn bitxor_assign(&mut self, rhs: B) {
let rhs = rhs.borrow();
@@ -1267,7 +1267,7 @@ impl std::ops::Not for FheBool {
///
/// let result = !a;
/// let result = result.decrypt(&client_key);
/// assert_eq!(result, false);
/// assert!(!result);
/// ```
fn not(self) -> Self::Output {
(&self).not()
@@ -1292,7 +1292,7 @@ impl std::ops::Not for &FheBool {
///
/// let result = !&a;
/// let result = result.decrypt(&client_key);
/// assert_eq!(result, false);
/// assert!(!result);
/// ```
fn not(self) -> Self::Output {
let ciphertext = global_state::with_internal_keys(|key| match key {

2
tfhe/src/high_level_api/booleans/compressed.rs
View File

@@ -29,7 +29,7 @@ use tfhe_versionable::Versionize;
///
/// let decompressed = compressed.decompress();
/// let decrypted: bool = decompressed.decrypt(&client_key);
/// assert_eq!(decrypted, true);
/// assert!(decrypted);
/// ```
#[derive(Clone, Serialize, Deserialize, Versionize)]
#[versionize(CompressedFheBoolVersions)]

2
tfhe/src/high_level_api/booleans/encrypt.rs
View File

@@ -45,7 +45,7 @@ impl FheTrivialEncrypt<bool> for FheBool {
/// let a = FheBool::encrypt_trivial(true);
///
/// let decrypted: bool = a.decrypt(&client_key);
/// assert_eq!(decrypted, true);
/// assert!(decrypted);
/// ```
#[track_caller]
fn encrypt_trivial(value: bool) -> Self {

120
tfhe/src/high_level_api/booleans/tests.rs
View File

@@ -25,19 +25,19 @@ fn xor_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
assert_degree_is_ok(ffalse);
let r = ffalse ^ ffalse;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse ^ ttrue;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue ^ ffalse;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue ^ ttrue;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -47,36 +47,36 @@ fn scalar_xor_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
// Scalar on the right
let r = ffalse ^ false;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse ^ true;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue ^ false;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue ^ true;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
// Scalar on the left
let r = false ^ ffalse;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = false ^ ttrue;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = true ^ ffalse;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = true ^ ttrue;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -85,19 +85,19 @@ fn and_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
assert_degree_is_ok(ffalse);
let r = ffalse & ffalse;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse & ttrue;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue & ffalse;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue & ttrue;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -107,36 +107,36 @@ fn scalar_and_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
// Scalar on the right
let r = ffalse & false;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse & true;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue & false;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue & true;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
// Scalar on the left
let r = false & ffalse;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = false & ttrue;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = true & ffalse;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = true & ttrue;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -145,19 +145,19 @@ fn or_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
assert_degree_is_ok(ffalse);
let r = ffalse | ffalse;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse | ttrue;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue | ffalse;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue | ttrue;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -167,36 +167,36 @@ fn scalar_or_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
// Scalar on the right
let r = ffalse | false;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse | true;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue | false;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue | true;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
// Scalar on the left
let r = false | ffalse;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = false | ttrue;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = true | ffalse;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = true | ttrue;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -205,11 +205,11 @@ fn not_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
assert_degree_is_ok(ffalse);
let r = !ffalse;
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = !ttrue;
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -218,19 +218,19 @@ fn eq_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
assert_degree_is_ok(ffalse);
let r = ffalse.eq(ttrue);
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue.eq(ffalse);
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue.eq(ttrue);
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse.eq(ffalse);
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -239,19 +239,19 @@ fn scalar_eq_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
assert_degree_is_ok(ffalse);
let r = ffalse.eq(true);
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue.eq(false);
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue.eq(true);
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse.eq(false);
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -260,19 +260,19 @@ fn ne_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
assert_degree_is_ok(ffalse);
let r = ffalse.ne(ttrue);
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue.ne(ffalse);
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue.ne(ttrue);
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse.ne(ffalse);
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -281,19 +281,19 @@ fn scalar_ne_truth_table(ttrue: &FheBool, ffalse: &FheBool, key: &ClientKey) {
assert_degree_is_ok(ffalse);
let r = ffalse.ne(true);
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue.ne(false);
assert_eq!(r.decrypt(key), true);
assert!(r.decrypt(key));
assert_degree_is_ok(&r);
let r = ttrue.ne(true);
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
let r = ffalse.ne(false);
assert_eq!(r.decrypt(key), false);
assert!(!r.decrypt(key));
assert_degree_is_ok(&r);
}
@@ -312,8 +312,8 @@ fn compressed_bool_test_case(setup_fn: impl FnOnce() -> (ClientKey, Device)) {
assert_eq!(a.current_device(), sks_device);
assert_eq!(b.current_device(), sks_device);
assert_eq!(a.decrypt(&cks), true);
assert_eq!(b.decrypt(&cks), false);
assert!(a.decrypt(&cks));
assert!(!b.decrypt(&cks));
}
mod cpu {
@@ -639,8 +639,8 @@ mod cpu {
assert_degree_is_ok(&a);
assert_degree_is_ok(&b);
assert_eq!(a.decrypt(&keys), true);
assert_eq!(b.decrypt(&keys), false);
assert!(a.decrypt(&keys));
assert!(!b.decrypt(&keys));
}
#[test]
@@ -654,7 +654,7 @@ mod cpu {
assert_degree_is_ok(&a);
let clear: bool = a.decrypt(&client_key);
assert_eq!(clear, true);
assert!(clear);
}
#[test]
@@ -669,7 +669,7 @@ mod cpu {
assert_degree_is_ok(&a);
let clear: bool = a.decrypt(&client_key);
assert_eq!(clear, true);
assert!(clear);
}
#[test]

4
tfhe/src/high_level_api/integers/signed/base.rs
View File

@@ -358,7 +358,7 @@ where
/// let (result, is_ok) = a.checked_ilog2();
///
/// let is_ok = is_ok.decrypt(&client_key);
/// assert_eq!(is_ok, false);
/// assert!(!is_ok);
///
/// let decrypted: u16 = result.decrypt(&client_key);
/// assert_eq!(decrypted, 15); // result is meaningless
@@ -411,7 +411,7 @@ where
///
/// // We cannot trivial decrypt
/// let result: Result<i16, _> = non_trivial.try_decrypt_trivial();
/// matches!(result, Err(_));
/// assert!(result.is_err());
/// ```
pub fn try_decrypt_trivial<Clear>(&self) -> Result<Clear, NotTrivialCiphertextError>
where

4
tfhe/src/high_level_api/integers/signed/ops.rs
View File

@@ -97,7 +97,7 @@ where
/// let result = a.max(&b);
///
/// let decrypted_max: i16 = result.decrypt(&client_key);
/// assert_eq!(decrypted_max, (-1i16).max(2i16));
/// assert_eq!(decrypted_max, 2i16);
/// ```
fn max(&self, rhs: &Self) -> Self::Output {
global_state::with_internal_keys(|keys| match keys {
@@ -143,7 +143,7 @@ where
/// let result = a.min(&b);
///
/// let decrypted_min: i16 = result.decrypt(&client_key);
/// assert_eq!(decrypted_min, (-1i16).min(2i16));
/// assert_eq!(decrypted_min, -1i16);
/// ```
fn min(&self, rhs: &Self) -> Self::Output {
global_state::with_internal_keys(|keys| match keys {

22
tfhe/src/high_level_api/integers/signed/overflowing_ops.rs
View File

@@ -36,7 +36,7 @@ where
/// overflowed.decrypt(&client_key),
/// i16::MAX.overflowing_add(1i16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: Self) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -85,7 +85,7 @@ where
/// overflowed.decrypt(&client_key),
/// i16::MAX.overflowing_add(1i16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: &Self) -> (Self::Output, FheBool) {
<&Self as OverflowingAdd<&Self>>::overflowing_add(&self, other)
@@ -122,7 +122,7 @@ where
/// overflowed.decrypt(&client_key),
/// i16::MAX.overflowing_add(1i16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: Clear) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -170,7 +170,7 @@ where
/// overflowed.decrypt(&client_key),
/// i16::MAX.overflowing_add(1i16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: Clear) -> (Self::Output, FheBool) {
(&self).overflowing_add(other)
@@ -209,7 +209,7 @@ where
/// overflowed.decrypt(&client_key),
/// i16::MAX.overflowing_add(1i16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: &FheInt<Id>) -> (Self::Output, FheBool) {
other.overflowing_add(self)
@@ -244,7 +244,7 @@ where
/// let result: i16 = result.decrypt(&client_key);
/// assert_eq!(result, expected_result);
/// assert_eq!(overflowed.decrypt(&client_key), expected_overflow);
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_sub(self, other: Self) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -291,7 +291,7 @@ where
/// let result: i16 = result.decrypt(&client_key);
/// assert_eq!(result, expected_result);
/// assert_eq!(overflowed.decrypt(&client_key), expected_overflow);
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_sub(self, other: &Self) -> (Self::Output, FheBool) {
<&Self as OverflowingSub<&Self>>::overflowing_sub(&self, other)
@@ -326,7 +326,7 @@ where
/// let result: i16 = result.decrypt(&client_key);
/// assert_eq!(result, expected_result);
/// assert_eq!(overflowed.decrypt(&client_key), expected_overflow);
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_sub(self, other: Clear) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -372,7 +372,7 @@ where
/// let result: i16 = result.decrypt(&client_key);
/// assert_eq!(result, expected_result);
/// assert_eq!(overflowed.decrypt(&client_key), expected_overflow);
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_sub(self, other: Clear) -> (Self::Output, FheBool) {
<&Self as OverflowingSub<Clear>>::overflowing_sub(&self, other)
@@ -407,7 +407,7 @@ where
/// let result: i16 = result.decrypt(&client_key);
/// assert_eq!(result, expected_result);
/// assert_eq!(overflowed.decrypt(&client_key), expected_overflowed);
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_mul(self, other: Self) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -454,7 +454,7 @@ where
/// let result: i16 = result.decrypt(&client_key);
/// assert_eq!(result, expected_result);
/// assert_eq!(overflowed.decrypt(&client_key), expected_overflowed);
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_mul(self, other: &Self) -> (Self::Output, FheBool) {
<&Self as OverflowingMul<&Self>>::overflowing_mul(&self, other)

4
tfhe/src/high_level_api/integers/signed/scalar_ops.rs
View File

@@ -42,7 +42,7 @@ where
/// let result = a.max(2i16);
///
/// let decrypted_max: i16 = result.decrypt(&client_key);
/// assert_eq!(decrypted_max, (-1i16).max(2i16));
/// assert_eq!(decrypted_max, 2i16);
/// ```
fn max(&self, rhs: Clear) -> Self::Output {
global_state::with_internal_keys(|keys| match keys {
@@ -89,7 +89,7 @@ where
/// let result = a.min(2i16);
///
/// let decrypted_min: i16 = result.decrypt(&client_key);
/// assert_eq!(decrypted_min, (-1i16).min(2i16));
/// assert_eq!(decrypted_min, -1i16);
/// ```
fn min(&self, rhs: Clear) -> Self::Output {
global_state::with_internal_keys(|keys| match keys {

6
tfhe/src/high_level_api/integers/unsigned/base.rs
View File

@@ -196,7 +196,7 @@ where
///
/// // We cannot trivial decrypt
/// let result: Result<u16, _> = non_trivial.try_decrypt_trivial();
/// matches!(result, Err(_));
/// assert!(result.is_err());
/// ```
pub fn try_decrypt_trivial<Clear>(&self) -> Result<Clear, NotTrivialCiphertextError>
where
@@ -460,7 +460,7 @@ where
/// let (result, is_ok) = a.checked_ilog2();
///
/// let is_ok = is_ok.decrypt(&client_key);
/// assert_eq!(is_ok, false);
/// assert!(!is_ok);
///
/// let decrypted: u16 = result.decrypt(&client_key);
/// assert_eq!(decrypted, 63); // result is meaningless
@@ -516,7 +516,7 @@ where
/// .unwrap(); // All possible output values fit in a u8
///
/// let matched = matched.decrypt(&client_key);
/// assert_eq!(matched, true);
/// assert!(matched);
///
/// let decrypted: u16 = result.decrypt(&client_key);
/// assert_eq!(decrypted, 25u16)

4
tfhe/src/high_level_api/integers/unsigned/ops.rs
View File

@@ -203,7 +203,7 @@ where
/// let result = a.max(&b);
///
/// let decrypted_max: u16 = result.decrypt(&client_key);
/// assert_eq!(decrypted_max, 1u16.max(2u16));
/// assert_eq!(decrypted_max, 2u16);
/// ```
fn max(&self, rhs: &Self) -> Self::Output {
global_state::with_internal_keys(|key| match key {
@@ -249,7 +249,7 @@ where
/// let result = a.min(&b);
///
/// let decrypted_min: u16 = result.decrypt(&client_key);
/// assert_eq!(decrypted_min, 1u16.min(2u16));
/// assert_eq!(decrypted_min, 1u16);
/// ```
fn min(&self, rhs: &Self) -> Self::Output {
global_state::with_internal_keys(|key| match key {

22
tfhe/src/high_level_api/integers/unsigned/overflowing_ops.rs
View File

@@ -38,7 +38,7 @@ where
/// overflowed.decrypt(&client_key),
/// u16::MAX.overflowing_add(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: Self) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -95,7 +95,7 @@ where
/// overflowed.decrypt(&client_key),
/// u16::MAX.overflowing_add(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: &Self) -> (Self::Output, FheBool) {
<&Self as OverflowingAdd<&Self>>::overflowing_add(&self, other)
@@ -132,7 +132,7 @@ where
/// overflowed.decrypt(&client_key),
/// u16::MAX.overflowing_add(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: Clear) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -188,7 +188,7 @@ where
/// overflowed.decrypt(&client_key),
/// u16::MAX.overflowing_add(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: Clear) -> (Self::Output, FheBool) {
(&self).overflowing_add(other)
@@ -227,7 +227,7 @@ where
/// overflowed.decrypt(&client_key),
/// u16::MAX.overflowing_add(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_add(self, other: &FheUint<Id>) -> (Self::Output, FheBool) {
other.overflowing_add(self)
@@ -264,7 +264,7 @@ where
/// overflowed.decrypt(&client_key),
/// 0u16.overflowing_sub(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_sub(self, other: Self) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -313,7 +313,7 @@ where
/// overflowed.decrypt(&client_key),
/// 0u16.overflowing_sub(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_sub(self, other: &Self) -> (Self::Output, FheBool) {
<&Self as OverflowingSub<&Self>>::overflowing_sub(&self, other)
@@ -350,7 +350,7 @@ where
/// overflowed.decrypt(&client_key),
/// 0u16.overflowing_sub(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_sub(self, other: Clear) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -398,7 +398,7 @@ where
/// overflowed.decrypt(&client_key),
/// 0u16.overflowing_sub(1u16).1
/// );
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_sub(self, other: Clear) -> (Self::Output, FheBool) {
<&Self as OverflowingSub<Clear>>::overflowing_sub(&self, other)
@@ -433,7 +433,7 @@ where
/// let result: u16 = result.decrypt(&client_key);
/// assert_eq!(result, expected_result);
/// assert_eq!(overflowed.decrypt(&client_key), expected_overflowed);
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_mul(self, other: Self) -> (Self::Output, FheBool) {
global_state::with_internal_keys(|key| match key {
@@ -480,7 +480,7 @@ where
/// let result: u16 = result.decrypt(&client_key);
/// assert_eq!(result, expected_result);
/// assert_eq!(overflowed.decrypt(&client_key), expected_overflowed);
/// assert_eq!(overflowed.decrypt(&client_key), true);
/// assert!(overflowed.decrypt(&client_key));
/// ```
fn overflowing_mul(self, other: &Self) -> (Self::Output, FheBool) {
<&Self as OverflowingMul<&Self>>::overflowing_mul(&self, other)

4
tfhe/src/high_level_api/integers/unsigned/scalar_ops.rs
View File

@@ -285,7 +285,7 @@ where
/// let result = a.max(b);
///
/// let decrypted_max: u16 = result.decrypt(&client_key);
/// assert_eq!(decrypted_max, 1u16.max(2u16));
/// assert_eq!(decrypted_max, 2u16);
/// ```
fn max(&self, rhs: Clear) -> Self::Output {
global_state::with_internal_keys(|key| match key {
@@ -331,7 +331,7 @@ where
/// let result = a.min(b);
///
/// let decrypted_min: u16 = result.decrypt(&client_key);
/// assert_eq!(decrypted_min, 1u16.min(2u16));
/// assert_eq!(decrypted_min, 1u16);
/// ```
fn min(&self, rhs: Clear) -> Self::Output {
global_state::with_internal_keys(|key| match key {

7
tfhe/src/high_level_api/keys/client.rs
View File

@@ -37,15 +37,14 @@ impl ClientKey {
/// Using the same seed between generations allows to regenerate the same key.
///
/// ```rust
/// use bincode;
/// use tfhe::{ClientKey, ConfigBuilder, Seed};
///
/// let builder = ConfigBuilder::default();
/// let config = builder.build();
///
/// let cks1 = ClientKey::generate_with_seed(config.clone(), Seed(125));
/// let cks2 = ClientKey::generate(config.clone());
/// let cks3 = ClientKey::generate_with_seed(config.clone(), Seed(125));
/// let cks1 = ClientKey::generate_with_seed(config, Seed(125));
/// let cks2 = ClientKey::generate(config);
/// let cks3 = ClientKey::generate_with_seed(config, Seed(125));
///
/// // The keys created with the same seed are equal
/// assert_eq!(

8
tfhe/src/integer/ciphertext/base.rs
View File

@@ -83,13 +83,13 @@ impl RadixCiphertext {
/// assert_eq!(Ok(msg), res);
///
/// let res = non_trivial_ct.decrypt_trivial::<u8>();
/// matches!(res, Err(_));
/// 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>();
/// matches!(res, Err(_));
/// assert!(res.is_err());
///
/// // Doing operations using only trivial ciphertexts
/// // will return a trivial
@@ -184,13 +184,13 @@ impl SignedRadixCiphertext {
/// assert_eq!(Ok(msg), res);
///
/// let res = non_trivial_ct.decrypt_trivial::<i8>();
/// matches!(res, Err(_));
/// 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::<i8>();
/// matches!(res, Err(_));
/// assert!(res.is_err());
///
/// // Doing operations using only trivial ciphertexts
/// // will return a trivial

2
tfhe/src/integer/ciphertext/boolean_value.rs
View File

@@ -158,7 +158,7 @@ impl BooleanBlock {
/// assert_eq!(Ok(msg), res);
///
/// let res = non_trivial_ct.decrypt_trivial();
/// matches!(res, Err(_));
/// assert!(res.is_err());
/// ```
pub fn decrypt_trivial(&self) -> Result<bool, NotTrivialCiphertextError> {
let value = self.0.decrypt_trivial()?;

4
tfhe/src/integer/client_key/mod.rs
View File

@@ -504,7 +504,7 @@ impl ClientKey {
///
/// let a = cks.encrypt_bool(false);
/// let dec = cks.decrypt_bool(&a);
/// assert_eq!(dec, false);
/// assert!(!dec);
///
/// let a = a.into_radix(size, &sks);
/// let dec: u64 = cks.decrypt(&a);
@@ -538,7 +538,7 @@ impl ClientKey {
/// let a = cks.encrypt_one_block(1u64);
/// let wrapped = BooleanBlock::new_unchecked(a);
/// let dec = cks.decrypt_bool(&wrapped);
/// assert_eq!(dec, true);
/// assert!(dec);
/// ```
pub fn decrypt_bool(&self, ct: &BooleanBlock) -> bool {
self.decrypt_one_block(&ct.0) != 0

2
tfhe/src/integer/gpu/server_key/radix/add.rs
View File

@@ -392,7 +392,7 @@ impl CudaServerKey {
/// let dec_result: u64 = cks.decrypt(&ct_res);
/// let dec_overflowed: bool = cks.decrypt_bool(&ct_overflowed);
/// assert_eq!(dec_result, (msg1 + msg2) % modulus);
/// assert_eq!(dec_overflowed, true);
/// assert!(dec_overflowed);
/// ```
pub fn unsigned_overflowing_add(
&self,

3
tfhe/src/integer/server_key/crt/scalar_add_crt.rs
View File

@@ -69,8 +69,7 @@ impl ServerKey {
/// // Encrypt two messages
/// let mut ctxt_1 = cks.encrypt(clear_1);
///
/// sks.is_crt_scalar_add_possible(&mut ctxt_1, clear_2)
/// .unwrap();
/// sks.is_crt_scalar_add_possible(&ctxt_1, clear_2).unwrap();
/// ```
pub fn is_crt_scalar_add_possible(
&self,

3
tfhe/src/integer/server_key/crt/scalar_mul_crt.rs
View File

@@ -72,8 +72,7 @@ impl ServerKey {
/// // Encrypt two messages
/// let mut ctxt_1 = cks.encrypt(clear_1);
///
/// sks.is_crt_scalar_mul_possible(&mut ctxt_1, clear_2)
/// .unwrap();
/// sks.is_crt_scalar_mul_possible(&ctxt_1, clear_2).unwrap();
/// ```
pub fn is_crt_scalar_mul_possible(
&self,

5
tfhe/src/integer/server_key/crt/scalar_sub_crt.rs
View File

@@ -62,8 +62,7 @@ impl ServerKey {
/// // Encrypt two messages
/// let mut ctxt_1 = cks.encrypt(clear_1);
///
/// sks.is_crt_scalar_sub_possible(&mut ctxt_1, clear_2)
/// .unwrap();
/// sks.is_crt_scalar_sub_possible(&ctxt_1, clear_2).unwrap();
///
/// // Decrypt
/// let res = cks.decrypt(&ctxt_1);
@@ -103,7 +102,7 @@ impl ServerKey {
///
/// let mut ctxt_1 = cks.encrypt(clear_1);
///
/// let ct_res = sks.checked_crt_scalar_sub(&mut ctxt_1, clear_2).unwrap();
/// let ct_res = sks.checked_crt_scalar_sub(&ctxt_1, clear_2).unwrap();
///
/// // Decrypt:
/// let dec = cks.decrypt(&ct_res);

4
tfhe/src/integer/server_key/crt/sub_crt.rs
View File

@@ -25,7 +25,7 @@ impl ServerKey {
/// let mut ctxt_1 = cks.encrypt(clear_1);
/// let mut ctxt_2 = cks.encrypt(clear_2);
///
/// let ctxt = sks.unchecked_crt_sub(&mut ctxt_1, &mut ctxt_2);
/// let ctxt = sks.unchecked_crt_sub(&ctxt_1, &ctxt_2);
///
/// // Decrypt
/// let res = cks.decrypt(&ctxt);
@@ -64,7 +64,7 @@ impl ServerKey {
/// let mut ctxt_1 = cks.encrypt(clear_1);
/// let mut ctxt_2 = cks.encrypt(clear_2);
///
/// let ctxt = sks.unchecked_crt_sub(&mut ctxt_1, &mut ctxt_2);
/// let ctxt = sks.unchecked_crt_sub(&ctxt_1, &ctxt_2);
///
/// // Decrypt
/// let res = cks.decrypt(&ctxt);

2
tfhe/src/integer/server_key/crt_parallel/scalar_sub_crt.rs
View File

@@ -79,7 +79,7 @@ impl ServerKey {
/// let mut ctxt_1 = cks.encrypt(clear_1);
///
/// let ct_res = sks
/// .checked_crt_scalar_sub_parallelized(&mut ctxt_1, clear_2)
/// .checked_crt_scalar_sub_parallelized(&ctxt_1, clear_2)
/// .unwrap();
///
/// // Decrypt:

4
tfhe/src/integer/server_key/crt_parallel/sub_crt.rs
View File

@@ -24,7 +24,7 @@ impl ServerKey {
/// let mut ctxt_1 = cks.encrypt(clear_1);
/// let mut ctxt_2 = cks.encrypt(clear_2);
///
/// let ctxt = sks.unchecked_crt_sub_parallelized(&mut ctxt_1, &mut ctxt_2);
/// let ctxt = sks.unchecked_crt_sub_parallelized(&ctxt_1, &ctxt_2);
///
/// // Decrypt
/// let res = cks.decrypt(&ctxt);
@@ -63,7 +63,7 @@ impl ServerKey {
/// let mut ctxt_1 = cks.encrypt(clear_1);
/// let mut ctxt_2 = cks.encrypt(clear_2);
///
/// let ctxt = sks.unchecked_crt_sub_parallelized(&mut ctxt_1, &mut ctxt_2);
/// let ctxt = sks.unchecked_crt_sub_parallelized(&ctxt_1, &ctxt_2);
///
/// // Decrypt
/// let res = cks.decrypt(&ctxt);

2
tfhe/src/integer/server_key/mod.rs
View File

@@ -85,7 +85,7 @@ impl ServerKey {
/// let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS);
///
/// // Generate the server key:
/// let sks = ServerKey::new_radix_server_key(&cks);
/// let sks = ServerKey::new_radix_server_key(cks);
/// ```
pub fn new_radix_server_key<C>(cks: C) -> Self
where

5
tfhe/src/integer/server_key/radix/bitwise_op.rs
View File

@@ -74,8 +74,7 @@ impl ServerKey {
/// let ct1 = cks.encrypt(msg1);
/// let ct2 = cks.encrypt(msg2);
///
/// let res = sks
/// .is_functional_bivariate_pbs_possible(&ct1, &ct2)
/// sks.is_functional_bivariate_pbs_possible(&ct1, &ct2)
/// .unwrap();
/// ```
pub fn is_functional_bivariate_pbs_possible<T>(
@@ -628,7 +627,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec_result = cks.decrypt_bool(&ct_is_in_range);
/// assert_eq!(dec_result, msg >= 10 && msg <= 15);
/// assert_eq!(dec_result, (10..=15).contains(&msg));
/// ```
pub fn boolean_bitand(&self, lhs: &BooleanBlock, rhs: &BooleanBlock) -> BooleanBlock {
let result = self.key.bitand(&lhs.0, &rhs.0);

2
tfhe/src/integer/server_key/radix/mod.rs
View File

@@ -728,7 +728,7 @@ impl ServerKey {
/// let mut ct2 = cks.encrypt(msg);
///
/// // Compute homomorphically an addition:
/// let mut ct_res = sks.unchecked_add(&mut ct1, &mut ct2);
/// let mut ct_res = sks.unchecked_add(&ct1, &ct2);
/// sks.full_propagate(&mut ct_res);
///
/// // Decrypt:

2
tfhe/src/integer/server_key/radix/mul.rs
View File

@@ -202,7 +202,7 @@ impl ServerKey {
/// let ctxt_2 = cks.encrypt(clear_2);
///
/// // Compute homomorphically a multiplication
/// let ct_res = sks.unchecked_mul(&mut ctxt_1, &ctxt_2);
/// let ct_res = sks.unchecked_mul(&ctxt_1, &ctxt_2);
///
/// // Decrypt
/// let res: u64 = cks.decrypt(&ct_res);

2
tfhe/src/integer/server_key/radix/scalar_add.rs
View File

@@ -135,7 +135,7 @@ impl ServerKey {
/// let mut ct = cks.encrypt(msg);
///
/// // Compute homomorphically an addition:
/// let ct_res = sks.checked_scalar_add(&mut ct, scalar).unwrap();
/// let ct_res = sks.checked_scalar_add(&ct, scalar).unwrap();
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct_res);

2
tfhe/src/integer/server_key/radix/shift.rs
View File

@@ -25,7 +25,7 @@ impl ServerKey {
/// // Encrypt two messages:
/// let mut ct = cks.encrypt(msg);
///
/// let ct_res = sks.blockshift_right(&mut ct, shift);
/// let ct_res = sks.blockshift_right(&ct, shift);
///
/// let div = cks.parameters().message_modulus().0.pow(shift as u32) as u64;
///

6
tfhe/src/integer/server_key/radix_parallel/div_mod.rs
View File

@@ -897,7 +897,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let div_by_0 = cks.decrypt_bool(&div_by_0);
/// assert_eq!(div_by_0, true);
/// assert!(div_by_0);
///
/// let q: u8 = cks.decrypt(&ct_q);
/// assert_eq!(u8::MAX, q);
@@ -949,7 +949,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let div_by_0 = cks.decrypt_bool(&div_by_0);
/// assert_eq!(div_by_0, true);
/// assert!(div_by_0);
///
/// let dec_result: u8 = cks.decrypt(&ct_res);
/// assert_eq!(u8::MAX, dec_result);
@@ -994,7 +994,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let rem_by_0 = cks.decrypt_bool(&rem_by_0);
/// assert_eq!(rem_by_0, true);
/// assert!(rem_by_0);
///
/// let dec_result: u8 = cks.decrypt(&ct_res);
/// assert_eq!(dec_result, msg);

2
tfhe/src/integer/server_key/radix_parallel/mod.rs
View File

@@ -201,7 +201,7 @@ impl ServerKey {
/// let mut ct2 = cks.encrypt(msg);
///
/// // Compute homomorphically an addition:
/// let mut ct_res = sks.unchecked_add(&mut ct1, &mut ct2);
/// let mut ct_res = sks.unchecked_add(&ct1, &ct2);
/// sks.full_propagate_parallelized(&mut ct_res);
///
/// // Decrypt:

2
tfhe/src/integer/server_key/radix_parallel/mul.rs
View File

@@ -393,7 +393,7 @@ impl ServerKey {
/// let ctxt_2 = cks.encrypt(clear_2);
///
/// // Compute homomorphically a multiplication
/// let ct_res = sks.unchecked_mul_parallelized(&mut ctxt_1, &ctxt_2);
/// let ct_res = sks.unchecked_mul_parallelized(&ctxt_1, &ctxt_2);
///
/// // Decrypt
/// let res: u64 = cks.decrypt(&ct_res);

2
tfhe/src/integer/server_key/radix_parallel/neg.rs
View File

@@ -68,7 +68,7 @@ impl ServerKey {
/// let mut ctxt = cks.encrypt(msg);
///
/// // Compute homomorphically a negation
/// let ct_res = sks.neg_parallelized(&mut ctxt);
/// let ct_res = sks.neg_parallelized(&ctxt);
///
/// // Decrypt
/// let dec: u64 = cks.decrypt(&ct_res);

2
tfhe/src/integer/server_key/radix_parallel/scalar_mul.rs
View File

@@ -162,7 +162,7 @@ impl ServerKey {
/// let mut ct = cks.encrypt(msg);
///
/// // Compute homomorphically a scalar multiplication:
/// let ct_res = sks.scalar_mul_parallelized(&mut ct, scalar);
/// let ct_res = sks.scalar_mul_parallelized(&ct, scalar);
///
/// // Decrypt:
/// let clear: u64 = cks.decrypt(&ct_res);

24
tfhe/src/integer/server_key/radix_parallel/scalar_rotate.rs
View File

@@ -35,7 +35,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct_res);
/// assert_eq!(msg.rotate_right(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_right(n) as u64, dec);
/// ```
pub fn smart_scalar_rotate_right_parallelized<T, Scalar>(&self, ct: &mut T, n: Scalar) -> T
where
@@ -76,7 +76,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct);
/// assert_eq!(msg.rotate_right(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_right(n) as u64, dec);
/// ```
pub fn smart_scalar_rotate_right_assign_parallelized<T, Scalar>(&self, ct: &mut T, n: Scalar)
where
@@ -125,7 +125,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct_res);
/// assert_eq!(msg.rotate_right(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_right(n) as u64, dec);
/// ```
pub fn scalar_rotate_right_parallelized<T, Scalar>(&self, ct_right: &T, n: Scalar) -> T
where
@@ -163,7 +163,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct);
/// assert_eq!(msg.rotate_right(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_right(n) as u64, dec);
/// ```
pub fn scalar_rotate_right_assign_parallelized<T, Scalar>(&self, ct: &mut T, n: Scalar)
where
@@ -212,7 +212,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct_res);
/// assert_eq!(msg.rotate_right(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_right(n) as u64, dec);
/// ```
pub fn unchecked_scalar_rotate_right_parallelized<T, Scalar>(&self, ct: &T, n: Scalar) -> T
where
@@ -259,7 +259,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct);
/// assert_eq!(msg.rotate_right(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_right(n) as u64, dec);
/// ```
pub fn unchecked_scalar_rotate_right_assign_parallelized<T, Scalar>(
&self,
@@ -366,7 +366,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct_res);
/// assert_eq!(msg.rotate_left(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_left(n) as u64, dec);
/// ```
pub fn smart_scalar_rotate_left_parallelized<T, Scalar>(&self, ct: &mut T, n: Scalar) -> T
where
@@ -407,7 +407,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct);
/// assert_eq!(msg.rotate_left(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_left(n) as u64, dec);
/// ```
pub fn smart_scalar_rotate_left_assign_parallelized<T, Scalar>(&self, ct: &mut T, n: Scalar)
where
@@ -456,7 +456,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct_res);
/// assert_eq!(msg.rotate_left(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_left(n) as u64, dec);
/// ```
pub fn scalar_rotate_left_parallelized<T, Scalar>(&self, ct_left: &T, n: Scalar) -> T
where
@@ -494,7 +494,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct);
/// assert_eq!(msg.rotate_left(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_left(n) as u64, dec);
/// ```
pub fn scalar_rotate_left_assign_parallelized<T, Scalar>(&self, ct: &mut T, n: Scalar)
where
@@ -543,7 +543,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct_res);
/// assert_eq!(msg.rotate_left(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_left(n) as u64, dec);
/// ```
pub fn unchecked_scalar_rotate_left_parallelized<T, Scalar>(&self, ct: &T, n: Scalar) -> T
where
@@ -590,7 +590,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let dec: u64 = cks.decrypt(&ct);
/// assert_eq!(msg.rotate_left(n as u32) as u64, dec);
/// assert_eq!(msg.rotate_left(n) as u64, dec);
/// ```
pub fn unchecked_scalar_rotate_left_assign_parallelized<T, Scalar>(&self, ct: &mut T, n: Scalar)
where

24
tfhe/src/integer/wopbs/mod.rs
View File

@@ -273,7 +273,7 @@ impl WopbsKey {
/// moduli *= cks.parameters().message_modulus().0 as u64;
/// }
/// let clear = 42 % moduli;
/// let ct = cks.encrypt(clear as u64);
/// let ct = cks.encrypt(clear);
/// let ct = wopbs_key.keyswitch_to_wopbs_params(&sks, &ct);
/// let lut = wopbs_key.generate_lut_radix(&ct, |x| x);
/// let ct_res = wopbs_key.wopbs(&ct, &lut);
@@ -363,7 +363,7 @@ impl WopbsKey {
/// moduli *= cks.parameters().message_modulus().0 as u64;
/// }
/// let clear = 15 % moduli;
/// let ct = cks.encrypt_without_padding(clear as u64);
/// let ct = cks.encrypt_without_padding(clear);
/// let lut = wopbs_key.generate_lut_radix_without_padding(&ct, |x| 2 * x);
/// let ct_res = wopbs_key.wopbs_without_padding(&ct, &lut);
/// let res: u64 = cks.decrypt_without_padding(&ct_res);
@@ -453,7 +453,7 @@ impl WopbsKey {
/// let clear = 42 % msg_space; // Encrypt the integers
/// let mut ct = cks.encrypt_native_crt(clear);
/// let lut = wopbs_key.generate_lut_native_crt(&ct, |x| x);
/// let ct_res = wopbs_key.wopbs_native_crt(&mut ct, &lut);
/// let ct_res = wopbs_key.wopbs_native_crt(&ct, &lut);
/// let res = cks.decrypt_native_crt(&ct_res);
/// assert_eq!(res, clear);
/// ```
@@ -480,8 +480,8 @@ impl WopbsKey {
/// }
/// let clear1 = 42 % moduli;
/// let clear2 = 24 % moduli;
/// let ct1 = cks.encrypt(clear1 as u64);
/// let ct2 = cks.encrypt(clear2 as u64);
/// let ct1 = cks.encrypt(clear1);
/// let ct2 = cks.encrypt(clear2);
///
/// let ct1 = wopbs_key.keyswitch_to_wopbs_params(&sks, &ct1);
/// let ct2 = wopbs_key.keyswitch_to_wopbs_params(&sks, &ct2);
@@ -519,7 +519,7 @@ impl WopbsKey {
/// moduli *= cks.parameters().message_modulus().0 as u64;
/// }
/// let clear = 42 % moduli;
/// let ct = cks.encrypt(clear as u64);
/// let ct = cks.encrypt(clear);
/// let ct = wopbs_key.keyswitch_to_wopbs_params(&sks, &ct);
/// let lut = wopbs_key.generate_lut_radix(&ct, |x| 2 * x);
/// let ct_res = wopbs_key.wopbs(&ct, &lut);
@@ -589,7 +589,7 @@ impl WopbsKey {
/// moduli *= cks.parameters().message_modulus().0 as u64;
/// }
/// let clear = 15 % moduli;
/// let ct = cks.encrypt_without_padding(clear as u64);
/// let ct = cks.encrypt_without_padding(clear);
/// let ct = wopbs_key.keyswitch_to_wopbs_params(&sks, &ct);
/// let lut = wopbs_key.generate_lut_radix_without_padding(&ct, |x| 2 * x);
/// let ct_res = wopbs_key.wopbs_without_padding(&ct, &lut);
@@ -655,7 +655,7 @@ impl WopbsKey {
/// let clear = 42 % msg_space; // Encrypt the integers
/// let mut ct = cks.encrypt_native_crt(clear);
/// let lut = wopbs_key.generate_lut_native_crt(&ct, |x| x);
/// let ct_res = wopbs_key.wopbs_native_crt(&mut ct, &lut);
/// let ct_res = wopbs_key.wopbs_native_crt(&ct, &lut);
/// let res = cks.decrypt_native_crt(&ct_res);
/// assert_eq!(res, clear);
/// ```
@@ -784,8 +784,8 @@ impl WopbsKey {
/// }
/// let clear1 = 42 % moduli;
/// let clear2 = 24 % moduli;
/// let ct1 = cks.encrypt(clear1 as u64);
/// let ct2 = cks.encrypt(clear2 as u64);
/// let ct1 = cks.encrypt(clear1);
/// let ct2 = cks.encrypt(clear2);
///
/// let ct1 = wopbs_key.keyswitch_to_wopbs_params(&sks, &ct1);
/// let ct2 = wopbs_key.keyswitch_to_wopbs_params(&sks, &ct2);
@@ -967,7 +967,7 @@ impl WopbsKey {
/// let mut ct1 = cks.encrypt_native_crt(clear1);
/// let mut ct2 = cks.encrypt_native_crt(clear2);
/// let lut = wopbs_key.generate_lut_bivariate_native_crt(&ct1, |x, y| x * y * 2);
/// let ct_res = wopbs_key.bivariate_wopbs_native_crt(&mut ct1, &mut ct2, &lut);
/// let ct_res = wopbs_key.bivariate_wopbs_native_crt(&ct1, &ct2, &lut);
/// let res = cks.decrypt_native_crt(&ct_res);
/// assert_eq!(res, (clear1 * clear2 * 2) % msg_space);
/// ```
@@ -1037,7 +1037,7 @@ impl WopbsKey {
/// let mut ct1 = cks.encrypt_native_crt(clear1);
/// let mut ct2 = cks.encrypt_native_crt(clear2);
/// let lut = wopbs_key.generate_lut_bivariate_native_crt(&ct1, |x, y| x * y * 2);
/// let ct_res = wopbs_key.bivariate_wopbs_native_crt(&mut ct1, &mut ct2, &lut);
/// let ct_res = wopbs_key.bivariate_wopbs_native_crt(&ct1, &ct2, &lut);
/// let res = cks.decrypt_native_crt(&ct_res);
/// assert_eq!(res, (clear1 * clear2 * 2) % msg_space);
/// ```

4
tfhe/src/shortint/ciphertext/standard.rs
View File

@@ -163,13 +163,13 @@ impl Ciphertext {
/// assert_eq!(Ok(1), res);
///
/// let res = non_trivial_ct.decrypt_trivial();
/// matches!(res, Err(_));
/// assert!(res.is_err());
///
/// // Doing operations that mixes trivial and non trivial
/// // will always return a non trivial
/// let ct_res = sks.add(&trivial_ct, &non_trivial_ct);
/// let res = ct_res.decrypt_trivial();
/// matches!(res, Err(_));
/// assert!(res.is_err());
///
/// // Doing operations using only trivial ciphertexts
/// // will return a trivial

6
tfhe/src/shortint/server_key/add.rs
View File

@@ -252,8 +252,7 @@ impl ServerKey {
/// let ct_right = cks.encrypt(msg);
///
/// // Check if we can perform an addition
/// let can_be_added = sks
/// .is_add_possible(ct_left.noise_degree(), ct_right.noise_degree())
/// sks.is_add_possible(ct_left.noise_degree(), ct_right.noise_degree())
/// .unwrap();
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
@@ -263,8 +262,7 @@ impl ServerKey {
/// let ct_right = cks.encrypt(msg);
///
/// // Check if we can perform an addition
/// let can_be_added = sks
/// .is_add_possible(ct_left.noise_degree(), ct_right.noise_degree())
/// sks.is_add_possible(ct_left.noise_degree(), ct_right.noise_degree())
/// .unwrap();
/// ```
pub fn is_add_possible(

48
tfhe/src/shortint/server_key/bitwise_op.rs
View File

@@ -36,7 +36,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg & msg, res);
/// assert_eq!(msg, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -49,7 +49,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg & msg, res);
/// assert_eq!(msg, res);
/// ```
pub fn bitand(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let mut ct_res = ct_left.clone();
@@ -235,7 +235,7 @@ impl ServerKey {
/// let ct_res = sks.checked_bitand(&ct1, &ct2).unwrap();
///
/// let clear_res = cks.decrypt(&ct_res);
/// assert_eq!(clear_res, msg & msg);
/// assert_eq!(clear_res, msg);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -247,7 +247,7 @@ impl ServerKey {
/// let ct_res = sks.checked_bitand(&ct1, &ct2).unwrap();
///
/// let clear_res = cks.decrypt(&ct_res);
/// assert_eq!(clear_res, msg & msg);
/// assert_eq!(clear_res, msg);
/// ```
pub fn checked_bitand(
&self,
@@ -289,7 +289,7 @@ impl ServerKey {
/// sks.checked_bitand_assign(&mut ct_left, &ct_right).unwrap();
///
/// let clear_res = cks.decrypt(&ct_left);
/// assert_eq!(clear_res, msg & msg);
/// assert_eq!(clear_res, msg);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -301,7 +301,7 @@ impl ServerKey {
/// sks.checked_bitand_assign(&mut ct_left, &ct_right).unwrap();
///
/// let clear_res = cks.decrypt(&ct_left);
/// assert_eq!(clear_res, msg & msg);
/// assert_eq!(clear_res, msg);
/// ```
pub fn checked_bitand_assign(
&self,
@@ -343,7 +343,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg & msg, res);
/// assert_eq!(msg, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -356,7 +356,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg & msg, res);
/// assert_eq!(msg, res);
/// ```
pub fn smart_bitand(&self, ct_left: &mut Ciphertext, ct_right: &mut Ciphertext) -> Ciphertext {
self.smart_evaluate_bivariate_function(ct_left, ct_right, |lhs, rhs| lhs & rhs)
@@ -446,7 +446,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg ^ msg, res);
/// assert_eq!(0, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -459,7 +459,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg ^ msg, res);
/// assert_eq!(0, res);
/// ```
pub fn bitxor(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let mut ct_res = ct_left.clone();
@@ -649,7 +649,7 @@ impl ServerKey {
/// let ct_res = sks.checked_bitxor(&ct1, &ct2).unwrap();
///
/// let clear_res = cks.decrypt(&ct_res);
/// assert_eq!(clear_res, msg ^ msg);
/// assert_eq!(clear_res, 0);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -660,7 +660,7 @@ impl ServerKey {
/// // Compute homomorphically a xor:
/// let ct_res = sks.checked_bitxor(&ct1, &ct2).unwrap();
/// let clear_res = cks.decrypt(&ct_res);
/// assert_eq!(clear_res, msg ^ msg);
/// assert_eq!(clear_res, 0);
/// ```
pub fn checked_bitxor(
&self,
@@ -702,7 +702,7 @@ impl ServerKey {
/// sks.checked_bitxor_assign(&mut ct_left, &ct_right).unwrap();
///
/// let clear_res = cks.decrypt(&ct_left);
/// assert_eq!(clear_res, msg ^ msg);
/// assert_eq!(clear_res, 0);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -714,7 +714,7 @@ impl ServerKey {
/// sks.checked_bitxor_assign(&mut ct_left, &ct_right).unwrap();
///
/// let clear_res = cks.decrypt(&ct_left);
/// assert_eq!(clear_res, msg ^ msg);
/// assert_eq!(clear_res, 0);
/// ```
pub fn checked_bitxor_assign(
&self,
@@ -756,7 +756,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg ^ msg, res);
/// assert_eq!(0, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -769,7 +769,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg ^ msg, res);
/// assert_eq!(0, res);
/// ```
pub fn smart_bitxor(&self, ct_left: &mut Ciphertext, ct_right: &mut Ciphertext) -> Ciphertext {
self.smart_evaluate_bivariate_function(ct_left, ct_right, |lhs, rhs| lhs ^ rhs)
@@ -859,7 +859,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg | msg, res);
/// assert_eq!(msg, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -872,7 +872,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg | msg, res);
/// assert_eq!(msg, res);
/// ```
pub fn bitor(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let mut ct_res = ct_left.clone();
@@ -1064,7 +1064,7 @@ impl ServerKey {
/// let ct_res = sks.checked_bitor(&ct1, &ct2).unwrap();
///
/// let clear_res = cks.decrypt(&ct_res);
/// assert_eq!(clear_res, msg | msg);
/// assert_eq!(clear_res, msg);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -1076,7 +1076,7 @@ impl ServerKey {
/// let ct_res = sks.checked_bitor(&ct1, &ct2).unwrap();
///
/// let clear_res = cks.decrypt(&ct_res);
/// assert_eq!(clear_res, msg | msg);
/// assert_eq!(clear_res, msg);
/// ```
pub fn checked_bitor(
&self,
@@ -1118,7 +1118,7 @@ impl ServerKey {
/// sks.checked_bitor_assign(&mut ct_left, &ct_right).unwrap();
///
/// let clear_res = cks.decrypt(&ct_left);
/// assert_eq!(clear_res, msg | msg);
/// assert_eq!(clear_res, msg);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -1130,7 +1130,7 @@ impl ServerKey {
/// sks.checked_bitor_assign(&mut ct_left, &ct_right).unwrap();
///
/// let clear_res = cks.decrypt(&ct_left);
/// assert_eq!(clear_res, msg | msg);
/// assert_eq!(clear_res, msg);
/// ```
pub fn checked_bitor_assign(
&self,
@@ -1172,7 +1172,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg | msg, res);
/// assert_eq!(msg, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -1185,7 +1185,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(msg | msg, res);
/// assert_eq!(msg, res);
/// ```
pub fn smart_bitor(&self, ct_left: &mut Ciphertext, ct_right: &mut Ciphertext) -> Ciphertext {
self.smart_evaluate_bivariate_function(ct_left, ct_right, |lhs, rhs| lhs | rhs)

48
tfhe/src/shortint/server_key/comp_op.rs
View File

@@ -41,7 +41,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg > msg) as u64, res);
/// assert_eq!(0, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -54,7 +54,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg > msg) as u64, res);
/// assert_eq!(0, res);
/// ```
pub fn greater(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let tmp_lhs: Ciphertext;
@@ -203,7 +203,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg > msg) as u64, res);
/// assert_eq!(0, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -216,7 +216,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg > msg) as u64, res);
/// assert_eq!(0, res);
/// ```
pub fn smart_greater(&self, ct_left: &mut Ciphertext, ct_right: &mut Ciphertext) -> Ciphertext {
self.smart_evaluate_bivariate_function(ct_left, ct_right, |lhs, rhs| u64::from(lhs > rhs))
@@ -254,7 +254,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg >= msg) as u64, res);
/// assert_eq!(1, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -267,7 +267,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg >= msg) as u64, res);
/// assert_eq!(1, res);
/// ```
pub fn greater_or_equal(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let tmp_lhs: Ciphertext;
@@ -369,7 +369,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg >= msg) as u64, res);
/// assert_eq!(1, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -382,7 +382,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg >= msg) as u64, res);
/// assert_eq!(1, res);
/// ```
pub fn smart_greater_or_equal(
&self,
@@ -474,7 +474,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg < msg) as u64, res);
/// assert_eq!(0, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -487,7 +487,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg < msg) as u64, res);
/// assert_eq!(0, res);
/// ```
pub fn less(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let tmp_lhs: Ciphertext;
@@ -638,7 +638,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg < msg) as u64, res);
/// assert_eq!(0, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -651,7 +651,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg < msg) as u64, res);
/// assert_eq!(0, res);
/// ```
pub fn smart_less(&self, ct_left: &mut Ciphertext, ct_right: &mut Ciphertext) -> Ciphertext {
self.smart_evaluate_bivariate_function(ct_left, ct_right, |lhs, rhs| u64::from(lhs < rhs))
@@ -689,7 +689,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg <= msg) as u64, res);
/// assert_eq!(1, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -702,7 +702,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg <= msg) as u64, res);
/// assert_eq!(1, res);
/// ```
pub fn less_or_equal(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let tmp_lhs: Ciphertext;
@@ -855,7 +855,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg <= msg) as u64, res);
/// assert_eq!(1, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -868,7 +868,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg <= msg) as u64, res);
/// assert_eq!(1, res);
/// ```
pub fn smart_less_or_equal(
&self,
@@ -910,7 +910,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg == msg) as u64, res);
/// assert_eq!(1, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -923,7 +923,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg == msg) as u64, res);
/// assert_eq!(1, res);
/// ```
pub fn equal(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let tmp_lhs: Ciphertext;
@@ -1072,7 +1072,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg == msg) as u64, res);
/// assert_eq!(1, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -1085,7 +1085,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg == msg) as u64, res);
/// assert_eq!(1, res);
/// ```
pub fn smart_equal(&self, ct_left: &mut Ciphertext, ct_right: &mut Ciphertext) -> Ciphertext {
self.smart_evaluate_bivariate_function(ct_left, ct_right, |lhs, rhs| u64::from(lhs == rhs))
@@ -1123,7 +1123,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg != msg) as u64, res);
/// assert_eq!(0, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -1136,7 +1136,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg != msg) as u64, res);
/// assert_eq!(0, res);
/// ```
pub fn not_equal(&self, ct_left: &Ciphertext, ct_right: &Ciphertext) -> Ciphertext {
let tmp_lhs: Ciphertext;
@@ -1285,7 +1285,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg != msg) as u64, res);
/// assert_eq!(0, res);
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -1298,7 +1298,7 @@ impl ServerKey {
///
/// // Decrypt:
/// let res = cks.decrypt(&ct_res);
/// assert_eq!((msg != msg) as u64, res);
/// assert_eq!(0, res);
/// ```
pub fn smart_not_equal(
&self,

18
tfhe/src/shortint/server_key/mul.rs
View File

@@ -269,8 +269,7 @@ impl ServerKey {
/// let ct_2 = cks.encrypt(msg);
///
/// // Check if we can perform a multiplication
/// let res = sks
/// .is_mul_possible(ct_1.noise_degree(), ct_2.noise_degree())
/// sks.is_mul_possible(ct_1.noise_degree(), ct_2.noise_degree())
/// .unwrap();
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
@@ -280,8 +279,7 @@ impl ServerKey {
/// let ct_2 = cks.encrypt(msg);
///
/// // Check if we can perform a multiplication
/// let res = sks
/// .is_mul_possible(ct_1.noise_degree(), ct_2.noise_degree())
/// sks.is_mul_possible(ct_1.noise_degree(), ct_2.noise_degree())
/// .unwrap();
/// ```
pub fn is_mul_possible(
@@ -503,7 +501,7 @@ impl ServerKey {
/// let mut ct_2 = cks.encrypt(clear_2);
///
/// // Compute homomorphically a multiplication
/// let ct_res = sks.unchecked_mul_lsb_small_carry(&mut ct_1, &mut ct_2);
/// let ct_res = sks.unchecked_mul_lsb_small_carry(&ct_1, &ct_2);
///
/// // Decrypt
/// let res = cks.decrypt(&ct_res);
@@ -516,7 +514,7 @@ impl ServerKey {
/// let mut ct_2 = cks.encrypt(clear_2);
///
/// // Compute homomorphically a multiplication
/// let ct_res = sks.unchecked_mul_lsb_small_carry(&mut ct_1, &mut ct_2);
/// let ct_res = sks.unchecked_mul_lsb_small_carry(&ct_1, &ct_2);
///
/// // Decrypt
/// let res = cks.decrypt(&ct_res);
@@ -623,9 +621,7 @@ impl ServerKey {
/// let mut ct_2 = cks.encrypt(msg_2);
///
/// // Compute homomorphically a multiplication
/// let ct_res = sks
/// .checked_mul_lsb_with_small_carry(&mut ct_1, &mut ct_2)
/// .unwrap();
/// let ct_res = sks.checked_mul_lsb_with_small_carry(&ct_1, &ct_2).unwrap();
///
/// let clear_res = cks.decrypt(&ct_res);
/// let modulus = cks.parameters.message_modulus().0 as u64;
@@ -638,9 +634,7 @@ impl ServerKey {
/// let mut ct_2 = cks.encrypt(msg_2);
///
/// // Compute homomorphically a multiplication
/// let ct_res = sks
/// .checked_mul_lsb_with_small_carry(&mut ct_1, &mut ct_2)
/// .unwrap();
/// let ct_res = sks.checked_mul_lsb_with_small_carry(&ct_1, &ct_2).unwrap();
///
/// let clear_res = cks.decrypt(&ct_res);
/// let modulus = cks.parameters.message_modulus().0 as u64;

8
tfhe/src/shortint/server_key/neg.rs
View File

@@ -36,7 +36,7 @@ impl ServerKey {
/// let mut ct = cks.encrypt(msg);
///
/// // Compute homomorphically a negation
/// let ct_res = sks.neg(&mut ct);
/// let ct_res = sks.neg(&ct);
///
/// // Decrypt
/// let clear_res = cks.decrypt(&ct_res);
@@ -49,7 +49,7 @@ impl ServerKey {
/// let mut ct = cks.encrypt(msg);
///
/// // Compute homomorphically a negation
/// let ct_res = sks.neg(&mut ct);
/// let ct_res = sks.neg(&ct);
///
/// // Decrypt
/// let clear_res = cks.decrypt(&ct_res);
@@ -263,7 +263,7 @@ impl ServerKey {
/// let ct = cks.encrypt(msg);
///
/// // Check if we can perform a negation
/// let can_be_negated = sks.is_neg_possible(ct.noise_degree()).unwrap();
/// sks.is_neg_possible(ct.noise_degree()).unwrap();
///
/// let (cks, sks) = gen_keys(PARAM_MESSAGE_2_CARRY_2_PBS_KS);
///
@@ -271,7 +271,7 @@ impl ServerKey {
/// let ct = cks.encrypt(msg);
///
/// // Check if we can perform a negation
/// let can_be_negated = sks.is_neg_possible(ct.noise_degree()).unwrap();
/// sks.is_neg_possible(ct.noise_degree()).unwrap();
/// ```
pub fn is_neg_possible(&self, ct: CiphertextNoiseDegree) -> Result<(), CheckError> {
// z = ceil( degree / 2^p ) x 2^p

8
tfhe/src/shortint/server_key/scalar_div_mod.rs
View File

@@ -61,7 +61,7 @@ impl ServerKey {
/// let mut ct_1 = cks.encrypt(clear_1);
///
/// // Compute homomorphically a multiplication
/// let ct_res = sks.unchecked_scalar_div(&mut ct_1, clear_2);
/// let ct_res = sks.unchecked_scalar_div(&ct_1, clear_2);
///
/// // Decrypt
/// let res = cks.decrypt(&ct_res);
@@ -73,7 +73,7 @@ impl ServerKey {
/// let mut ct_1 = cks.encrypt(clear_1);
///
/// // Compute homomorphically a multiplication
/// let ct_res = sks.unchecked_scalar_div(&mut ct_1, clear_2);
/// let ct_res = sks.unchecked_scalar_div(&ct_1, clear_2);
///
/// // Decrypt
/// let res = cks.decrypt(&ct_res);
@@ -152,7 +152,7 @@ impl ServerKey {
///
/// let modulus: u8 = 2;
/// // Compute homomorphically an addition:
/// let ct_res = sks.unchecked_scalar_mod(&mut ct, modulus);
/// let ct_res = sks.unchecked_scalar_mod(&ct, modulus);
///
/// // Decrypt:
/// let dec = cks.decrypt(&ct_res);
@@ -164,7 +164,7 @@ impl ServerKey {
///
/// let modulus: u8 = 2;
/// // Compute homomorphically an addition:
/// let ct_res = sks.unchecked_scalar_mod(&mut ct, modulus);
/// let ct_res = sks.unchecked_scalar_mod(&ct, modulus);
///
/// // Decrypt:
/// let dec = cks.decrypt(&ct_res);

4
tfhe/src/shortint/server_key/scalar_mul.rs
View File

@@ -34,7 +34,7 @@ impl ServerKey {
/// let mut ct = cks.encrypt(msg);
///
/// // Compute homomorphically a scalar multiplication:
/// let ct_res = sks.scalar_mul(&mut ct, scalar);
/// let ct_res = sks.scalar_mul(&ct, scalar);
///
/// // Our result is what we expect
/// let clear = cks.decrypt(&ct_res);
@@ -47,7 +47,7 @@ impl ServerKey {
/// let mut ct = cks.encrypt(msg);
///
/// // Compute homomorphically a scalar multiplication:
/// let ct_res = sks.scalar_mul(&mut ct, scalar);
/// let ct_res = sks.scalar_mul(&ct, scalar);
///
/// // Our result is what we expect
/// let clear = cks.decrypt(&ct_res);

4
tfhe/src/shortint/server_key/scalar_sub.rs
View File

@@ -36,7 +36,7 @@ impl ServerKey {
/// let mut ct = cks.encrypt(msg);
///
/// // Compute homomorphically a scalar multiplication:
/// let ct_res = sks.scalar_sub(&mut ct, scalar);
/// let ct_res = sks.scalar_sub(&ct, scalar);
///
/// // The input ciphertext content is not changed
/// assert_eq!(cks.decrypt(&ct), msg);
@@ -52,7 +52,7 @@ impl ServerKey {
/// let mut ct = cks.encrypt(msg);
///
/// // Compute homomorphically a scalar multiplication:
/// let ct_res = sks.scalar_sub(&mut ct, scalar);
/// let ct_res = sks.scalar_sub(&ct, scalar);
///
/// // The input ciphertext content is not changed
/// assert_eq!(cks.decrypt(&ct), msg);

4
tfhe/src/shortint/server_key/shift.rs
View File

@@ -303,7 +303,7 @@ impl ServerKey {
/// // | 0 0 | 0 1 |
///
/// let shift: u8 = 1;
/// let ct_res = sks.scalar_left_shift(&mut ct, shift);
/// let ct_res = sks.scalar_left_shift(&ct, shift);
/// // | ct_res |
/// // | carry | message |
/// // |-------|---------|
@@ -325,7 +325,7 @@ impl ServerKey {
/// // | 0 0 | 0 1 |
///
/// let shift: u8 = 1;
/// let ct_res = sks.scalar_left_shift(&mut ct, shift);
/// let ct_res = sks.scalar_left_shift(&ct, shift);
/// // | ct_res |
/// // | carry | message |
/// // |-------|---------|

2
tfhe/src/shortint/server_key/sub.rs
View File

@@ -31,7 +31,7 @@ impl ServerKey {
/// let ct_2 = cks.encrypt(1);
///
/// // Compute homomorphically a subtraction:
/// let ct_res = sks.sub(&mut ct_1, &ct_2);
/// let ct_res = sks.sub(&ct_1, &ct_2);
///
/// let clear_res = cks.decrypt(&ct_res);
/// let modulus = cks.parameters.message_modulus().0 as u64;

2
tfhe/src/shortint/wopbs/mod.rs
View File

@@ -338,7 +338,7 @@ impl WopbsKey {
/// let m = 2;
/// let mut ct = cks.encrypt(m);
/// let lut = wopbs_key.generate_lut(&ct, |x| x * x % message_modulus);
/// let ct_res = wopbs_key.programmable_bootstrapping(&sks, &mut ct, &lut);
/// let ct_res = wopbs_key.programmable_bootstrapping(&sks, &ct, &lut);
/// let res = cks.decrypt(&ct_res);
/// assert_eq!(res, (m * m) % message_modulus);
/// ```