tfhe 1.6.0

TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use super::{CrtCiphertext, RadixCiphertext, SignedRadixCiphertext};
use crate::shortint::Ciphertext;

pub trait IntegerCiphertext: Clone {
    fn blocks(&self) -> &[Ciphertext];
    fn moduli(&self) -> Vec<u64> {
        self.blocks().iter().map(|x| x.message_modulus.0).collect()
    }

    fn from_blocks(blocks: Vec<Ciphertext>) -> Self;

    fn blocks_mut(&mut self) -> &mut [Ciphertext];
}

pub trait IntegerRadixCiphertext: IntegerCiphertext + Sync + Send + From<Vec<Ciphertext>> {
    const IS_SIGNED: bool;

    fn block_carries_are_empty(&self) -> bool {
        self.blocks().iter().all(Ciphertext::carry_is_empty)
    }

    /// Returns whether the ciphertext _seems_ like it holds/encrypts
    /// a boolean (0 or 1) value.
    ///
    /// Since it uses degree to do so, it will not
    /// always return the correct answer.
    fn holds_boolean_value(&self) -> bool {
        self.blocks()[0].degree.get() <= 1
            && self.blocks()[1..]
                .iter()
                .all(|block| block.degree.get() == 0)
    }

    fn into_blocks(self) -> Vec<Ciphertext>;
}

impl IntegerCiphertext for RadixCiphertext {
    fn blocks(&self) -> &[Ciphertext] {
        &self.blocks
    }

    fn from_blocks(blocks: Vec<Ciphertext>) -> Self {
        Self::from(blocks)
    }

    fn blocks_mut(&mut self) -> &mut [Ciphertext] {
        &mut self.blocks
    }
}

impl IntegerRadixCiphertext for RadixCiphertext {
    const IS_SIGNED: bool = false;

    fn into_blocks(self) -> Vec<Ciphertext> {
        self.blocks
    }
}

impl IntegerCiphertext for SignedRadixCiphertext {
    fn blocks(&self) -> &[Ciphertext] {
        &self.blocks
    }

    fn from_blocks(blocks: Vec<Ciphertext>) -> Self {
        Self::from(blocks)
    }

    fn blocks_mut(&mut self) -> &mut [Ciphertext] {
        &mut self.blocks
    }
}

impl IntegerRadixCiphertext for SignedRadixCiphertext {
    const IS_SIGNED: bool = true;

    fn into_blocks(self) -> Vec<Ciphertext> {
        self.blocks
    }
}

impl IntegerCiphertext for CrtCiphertext {
    fn blocks(&self) -> &[Ciphertext] {
        &self.blocks
    }

    fn from_blocks(blocks: Vec<Ciphertext>) -> Self {
        let moduli = blocks.iter().map(|x| x.message_modulus.0).collect();
        Self { blocks, moduli }
    }

    fn blocks_mut(&mut self) -> &mut [Ciphertext] {
        &mut self.blocks
    }

    fn moduli(&self) -> Vec<u64> {
        self.moduli.clone()
    }
}

// Yet another trait, this is to avoid breaking the logic with IntegerCiphertext which BooleanBlock
// does not implement for good reasons IIRC.
pub trait AsShortintCiphertextSlice {
    fn as_ciphertext_slice(&self) -> &[Ciphertext];
}

impl<T: IntegerCiphertext> AsShortintCiphertextSlice for T {
    fn as_ciphertext_slice(&self) -> &[Ciphertext] {
        self.blocks()
    }
}

impl AsShortintCiphertextSlice for super::BooleanBlock {
    fn as_ciphertext_slice(&self) -> &[Ciphertext] {
        core::slice::from_ref(&self.0)
    }
}