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

use crate::shortint::backward_compatibility::noise_squashing::CompressedAtomicPatternNoiseSquashingKeyVersions;
use crate::shortint::client_key::atomic_pattern::AtomicPatternClientKey;
use crate::shortint::noise_squashing::NoiseSquashingPrivateKey;
use ks32::CompressedKS32AtomicPatternNoiseSquashingKey;
use standard::CompressedStandardAtomicPatternNoiseSquashingKey;

use serde::{Deserialize, Serialize};
use tfhe_versionable::Versionize;

use super::AtomicPatternNoiseSquashingKey;

pub mod ks32;
pub mod standard;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Versionize)]
#[versionize(CompressedAtomicPatternNoiseSquashingKeyVersions)]
pub enum CompressedAtomicPatternNoiseSquashingKey {
    Standard(CompressedStandardAtomicPatternNoiseSquashingKey),
    KeySwitch32(CompressedKS32AtomicPatternNoiseSquashingKey),
}

impl CompressedAtomicPatternNoiseSquashingKey {
    pub fn new(
        cks: &AtomicPatternClientKey,
        noise_squashing_private_key: &NoiseSquashingPrivateKey,
    ) -> Self {
        match cks {
            AtomicPatternClientKey::Standard(std_cks) => {
                Self::Standard(CompressedStandardAtomicPatternNoiseSquashingKey::new(
                    std_cks,
                    noise_squashing_private_key,
                ))
            }
            AtomicPatternClientKey::KeySwitch32(ks32_cks) => {
                Self::KeySwitch32(CompressedKS32AtomicPatternNoiseSquashingKey::new(
                    ks32_cks,
                    noise_squashing_private_key,
                ))
            }
        }
    }

    pub fn decompress(&self) -> AtomicPatternNoiseSquashingKey {
        match self {
            Self::Standard(std_compressed) => {
                AtomicPatternNoiseSquashingKey::Standard(std_compressed.decompress())
            }
            Self::KeySwitch32(ks32_compressed) => {
                AtomicPatternNoiseSquashingKey::KeySwitch32(ks32_compressed.decompress())
            }
        }
    }
}