tfhe 1.6.1

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
117
118
119
120
121
122
123
124
125
126

use super::stride::DynDimensions;
use super::traits::{ArithmeticArrayBackend, BitwiseArrayBackend};
use crate::high_level_api::array::{ArrayBackend, BackendDataContainer, FheArrayBase};

use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Not, Rem, Sub};

macro_rules! impl_other_binary_ops_variants {
    (
        $trait_name:ident($trait_method:ident) => $backend_trait:ident($backend_method:ident)
    ) => {
        impl<'a, 'b, C1, C2, Id> $trait_name<&'a FheArrayBase<C2, Id>> for &'b FheArrayBase<C1, Id>
        where
            Id: Default,
            C1: BackendDataContainer<Backend = C2::Backend>,
            C2: BackendDataContainer,
            C1::Backend: $backend_trait,
        {
            type Output = FheArrayBase<<C1::Backend as ArrayBackend>::Owned, Id>;

            fn $trait_method(self, rhs: &'a FheArrayBase<C2, Id>) -> Self::Output {
                if !self.has_same_shape(rhs) {
                    panic!("Array operands do not have the same shape");
                }
                let result =
                    C1::Backend::$backend_method(self.as_tensor_slice(), rhs.as_tensor_slice());
                let resulting_shape = DynDimensions::from(self.shape().to_vec());
                FheArrayBase::new(result, resulting_shape)
            }
        }

        impl<'a, C1, C2, Id> $trait_name<FheArrayBase<C2, Id>> for &'a FheArrayBase<C1, Id>
        where
            Id: Default,
            C1: BackendDataContainer<Backend = C2::Backend>,
            C2: BackendDataContainer,
            C1::Backend: $backend_trait,
        {
            type Output = FheArrayBase<<C1::Backend as ArrayBackend>::Owned, Id>;

            fn $trait_method(self, rhs: FheArrayBase<C2, Id>) -> Self::Output {
                if !self.has_same_shape(&rhs) {
                    panic!("Array operands do not have the same shape");
                }
                let result =
                    C1::Backend::$backend_method(self.as_tensor_slice(), rhs.as_tensor_slice());
                let resulting_shape = DynDimensions::from(self.shape().to_vec());
                FheArrayBase::new(result, resulting_shape)
            }
        }

        impl<'a, C1, C2, Id> $trait_name<&'a FheArrayBase<C2, Id>> for FheArrayBase<C1, Id>
        where
            Id: Default,
            C1: BackendDataContainer<Backend = C2::Backend>,
            C2: BackendDataContainer,
            C1::Backend: $backend_trait,
        {
            type Output = FheArrayBase<<C1::Backend as ArrayBackend>::Owned, Id>;

            fn $trait_method(self, rhs: &'a FheArrayBase<C2, Id>) -> Self::Output {
                if !self.has_same_shape(rhs) {
                    panic!("Array operands do not have the same shape");
                }
                let result =
                    C1::Backend::$backend_method(self.as_tensor_slice(), rhs.as_tensor_slice());
                let resulting_shape = DynDimensions::from(self.shape().to_vec());
                FheArrayBase::new(result, resulting_shape)
            }
        }

        impl<C1, C2, Id> $trait_name<FheArrayBase<C2, Id>> for FheArrayBase<C1, Id>
        where
            Id: Default,
            C1: BackendDataContainer<Backend = C2::Backend>,
            C2: BackendDataContainer,
            C1::Backend: $backend_trait,
        {
            type Output = FheArrayBase<<C1::Backend as ArrayBackend>::Owned, Id>;

            fn $trait_method(self, rhs: FheArrayBase<C2, Id>) -> Self::Output {
                if !self.has_same_shape(&rhs) {
                    panic!("Array operands do not have the same shape");
                }
                let result =
                    C1::Backend::$backend_method(self.as_tensor_slice(), rhs.as_tensor_slice());
                let resulting_shape = DynDimensions::from(self.shape().to_vec());
                FheArrayBase::new(result, resulting_shape)
            }
        }
    };
}
impl_other_binary_ops_variants!(Add(add) => ArithmeticArrayBackend(add_slices));
impl_other_binary_ops_variants!(Sub(sub) => ArithmeticArrayBackend(sub_slices));
impl_other_binary_ops_variants!(Mul(mul) => ArithmeticArrayBackend(mul_slices));
impl_other_binary_ops_variants!(Div(div) => ArithmeticArrayBackend(div_slices));
impl_other_binary_ops_variants!(Rem(rem) => ArithmeticArrayBackend(rem_slices));
impl_other_binary_ops_variants!(BitAnd(bitand) => BitwiseArrayBackend(bitand));
impl_other_binary_ops_variants!(BitOr(bitor) => BitwiseArrayBackend(bitor));
impl_other_binary_ops_variants!(BitXor(bitxor) => BitwiseArrayBackend(bitxor));

impl<C1, Id, O> Not for FheArrayBase<C1, Id>
where
    C1: BackendDataContainer,
    C1::Backend: BitwiseArrayBackend,
    for<'a> &'a Self: Not<Output = O>,
{
    type Output = O;

    fn not(self) -> Self::Output {
        !(&self)
    }
}

impl<C1, Id> Not for &FheArrayBase<C1, Id>
where
    Id: Default,
    C1: BackendDataContainer,
    C1::Backend: BitwiseArrayBackend,
{
    type Output = FheArrayBase<<C1::Backend as ArrayBackend>::Owned, Id>;

    fn not(self) -> Self::Output {
        let result = C1::Backend::bitnot(self.as_tensor_slice());
        FheArrayBase::new(result, self.dims.clone())
    }
}