fusion TFHE to use GFHE underthehood

README.md

@@ -19,8 +19,8 @@ and the line `type S = TWLE` to use `CKKS` or `BFV`.
 
 ```rust
 const T: u64 = 128; // msg space (msg modulus)
-const K: usize = 16;
-type S = TLWE<K>;
+type M = Rq<T, 1>; // msg space
+type S = TLWE<256>;
 
 let mut rng = rand::thread_rng();
 let msg_dist = Uniform::new(0_u64, T);
@@ -28,13 +28,13 @@ let msg_dist = Uniform::new(0_u64, T);
 let (sk, pk) = S::new_key(&mut rng)?;
 
 // get two random msgs in Z_t
-let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
-let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
-let m3 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
+let m1 = M::rand_u64(&mut rng, msg_dist)?;
+let m2 = M::rand_u64(&mut rng, msg_dist)?;
+let m3 = M::rand_u64(&mut rng, msg_dist)?;
 
 // encode the msgs into the plaintext space
-let p1: Tn<1> = S::encode::<T>(&m1); // plaintext
-let p2: Tn<1> = S::encode::<T>(&m2); // plaintext
+let p1 = S::encode::<T>(&m1); // plaintext
+let p2 = S::encode::<T>(&m2); // plaintext
 let c3_const: Tn<1> = Tn(array::from_fn(|i| T64(m3.coeffs()[i].0))); // encode it as constant value
 
 let c1 = S::encrypt(&mut rng, &pk, &p1)?;
@@ -42,8 +42,8 @@ let c2 = S::encrypt(&mut rng, &pk, &p2)?;
 
 // now we can do encrypted operations (notice that we do them using simple
 // operations by operator overloading):
-let c3 = c1 + c2;
-let c4 = c2 * c3_const;
+let c_12 = c1 + c2;
+let c4 = c_12 * c3_const;
 
 // decrypt & decode
 let p4_recovered = c4.decrypt(&sk);

arith/src/ring.rs

@@ -3,8 +3,8 @@ use std::fmt::Debug;
 use std::iter::Sum;
 use std::ops::{Add, AddAssign, Mul, Sub, SubAssign};
 
-/// Represents a ring element. Currently implemented by ring_n.rs#R and
-/// ring_nq.rs#Rq. Is not a 'pure algebraic ring', but more a custom trait
+/// Represents a ring element. Currently implemented by ring_nq.rs#Rq and
+/// ring_torus.rs#Tn. Is not a 'pure algebraic ring', but more a custom trait
 /// definition which includes methods like `mod_switch`.
 // assumed to be mod (X^N +1)
 pub trait Ring:

gfhe/src/glev.rs

@@ -73,11 +73,11 @@ mod tests {
 
         // let delta: u64 = Q / T; // floored
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = GLWE::<Rq<Q, N>, K>::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
             let m: Rq<Q, N> = m.remodule::<Q>();
 

gfhe/src/glwe.rs

@@ -17,12 +17,12 @@ const ERR_SIGMA: f64 = 3.2;
 /// GLWE implemented over the `Ring` trait, so that it can be also instantiated
 /// over the Torus polynomials 𝕋_<N,q>[X] = 𝕋_q[X]/ (X^N+1).
 #[derive(Clone, Debug)]
-pub struct GLWE<R: Ring, const K: usize>(TR<R, K>, R);
+pub struct GLWE<R: Ring, const K: usize>(pub TR<R, K>, pub R);
 
 #[derive(Clone, Debug)]
-pub struct SecretKey<R: Ring, const K: usize>(TR<R, K>);
+pub struct SecretKey<R: Ring, const K: usize>(pub TR<R, K>);
 #[derive(Clone, Debug)]
-pub struct PublicKey<R: Ring, const K: usize>(R, TR<R, K>);
+pub struct PublicKey<R: Ring, const K: usize>(pub R, pub TR<R, K>);
 
 // K GLevs, each KSK_i=l GLWEs
 #[derive(Clone, Debug)]
@@ -261,11 +261,11 @@ mod tests {
         type S = GLWE<Rq<Q, N>, K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?; // msg
                                                                // let m: Rq<Q, N> = m.remodule::<Q>();
 
@@ -306,11 +306,11 @@ mod tests {
         type S = GLWE<Tn<4>, K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_f64, T as f64);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_f64, T as f64);
             let m = Rq::<T, 4>::rand(&mut rng, msg_dist); // msg
 
             let p = t_encode::<T>(&m); // plaintext
@@ -340,11 +340,11 @@ mod tests {
         type S = GLWE<Rq<Q, N>, K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
             let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
             let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
@@ -373,11 +373,11 @@ mod tests {
         type S = GLWE<Rq<Q, N>, K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
             let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
             let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
@@ -405,11 +405,11 @@ mod tests {
         type S = GLWE<Rq<Q, N>, K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
             let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
             let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
@@ -438,11 +438,11 @@ mod tests {
         type S = GLWE<Rq<Q, N>, K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
 
             let p = S::encode::<T>(&m);

tfhe/src/lib.rs

@@ -5,94 +5,5 @@
 #![allow(clippy::upper_case_acronyms)]
 #![allow(dead_code)] // TMP
 
-use anyhow::Result;
-use rand::Rng;
-use rand_distr::{Normal, Uniform};
-use std::array;
-
-use arith::{Ring, Rq, Tn, T64};
-use gfhe::{glwe, GLWE};
-
 pub mod tlev;
 pub mod tlwe;
-
-#[derive(Clone, Debug)]
-pub struct SecretKey<const K: usize>(glwe::SecretKey<Tn<1>, K>);
-#[derive(Clone, Debug)]
-pub struct PublicKey<const K: usize>(glwe::PublicKey<Tn<1>, K>);
-
-#[derive(Clone, Debug)]
-pub struct TLWE<const K: usize>(pub GLWE<Tn<1>, K>);
-
-impl<const K: usize> TLWE<K> {
-    pub fn new_key(rng: impl Rng) -> Result<(SecretKey<K>, PublicKey<K>)> {
-        let (sk, pk) = GLWE::new_key(rng)?;
-        Ok((SecretKey(sk), PublicKey(pk)))
-    }
-
-    pub fn encode<const P: u64>(m: &Rq<P, 1>) -> Tn<1> {
-        let delta = u64::MAX / P; // floored
-        let coeffs = m.coeffs();
-        Tn(array::from_fn(|i| T64(coeffs[i].0 * delta)))
-    }
-    pub fn decode<const P: u64>(p: &Tn<1>) -> Rq<P, 1> {
-        let p = p.mul_div_round(P, u64::MAX);
-        Rq::<P, 1>::from_vec_u64(p.coeffs().iter().map(|c| c.0).collect())
-    }
-    pub fn encrypt_s(rng: impl Rng, sk: &SecretKey<K>, p: &Tn<1>) -> Result<Self> {
-        let glwe = GLWE::encrypt_s(rng, &sk.0, p)?;
-        Ok(Self(glwe))
-    }
-
-    pub fn encrypt(rng: impl Rng, pk: &PublicKey<K>, p: &Tn<1>) -> Result<Self> {
-        let glwe = GLWE::encrypt(rng, &pk.0, p)?;
-        Ok(Self(glwe))
-    }
-
-    pub fn decrypt(&self, sk: &SecretKey<K>) -> Tn<1> {
-        self.0.decrypt(&sk.0)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use anyhow::Result;
-    use rand::distributions::Uniform;
-
-    use super::*;
-
-    #[test]
-    fn test_encrypt_decrypt() -> Result<()> {
-        const T: u64 = 128; // plaintext modulus
-        const K: usize = 16;
-        type S = TLWE<K>;
-
-        // let delta: u64 = Q / T; // floored
-        let mut rng = rand::thread_rng();
-
-        for _ in 0..200 {
-            let (sk, pk) = S::new_key(&mut rng)?;
-
-            let msg_dist = Uniform::new(0_f64, T as f64);
-            let m = Rq::<T, 1>::rand(&mut rng, msg_dist); // msg
-
-            // let m: Rq<Q, N> = m.remodule::<Q>();
-
-            let p = S::encode::<T>(&m); // plaintext
-            let c = S::encrypt(&mut rng, &pk, &p)?; // ciphertext
-            let p_recovered = c.decrypt(&sk);
-            let m_recovered = S::decode::<T>(&p_recovered);
-
-            assert_eq!(m, m_recovered);
-
-            // same but using encrypt_s (with sk instead of pk))
-            let c = S::encrypt_s(&mut rng, &sk, &p)?;
-            let p_recovered = c.decrypt(&sk);
-            let m_recovered = S::decode::<T>(&p_recovered);
-
-            assert_eq!(m.remodule::<T>(), m_recovered.remodule::<T>());
-        }
-
-        Ok(())
-    }
-}

tfhe/src/tlev.rs

@@ -72,11 +72,11 @@ mod tests {
         let l: u32 = 16;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = TLWE::<K>::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m: Rq<T, 1> = Rq::rand_u64(&mut rng, msg_dist)?;
             let p: Tn<1> = S::encode::<T>(&m); // plaintext
 

tfhe/src/tlwe.rs

@@ -8,32 +8,26 @@ use std::iter::Sum;
 use std::ops::{Add, AddAssign, Mul, Sub};
 
 use arith::{Ring, Rq, Tn, T64, TR};
+use gfhe::{glwe, GLWE};
 
 const ERR_SIGMA: f64 = 3.2;
 
 #[derive(Clone, Debug)]
-pub struct TLWE<const K: usize>(TR<Tn<1>, K>, Tn<1>);
-
+pub struct SecretKey<const K: usize>(glwe::SecretKey<Tn<1>, K>);
 #[derive(Clone, Debug)]
-pub struct SecretKey<const K: usize>(TR<Tn<1>, K>);
+pub struct PublicKey<const K: usize>(glwe::PublicKey<Tn<1>, K>);
+
 #[derive(Clone, Debug)]
-pub struct PublicKey<const K: usize>(Tn<1>, TR<Tn<1>, K>);
+pub struct TLWE<const K: usize>(pub GLWE<Tn<1>, K>);
 
 impl<const K: usize> TLWE<K> {
     pub fn zero() -> Self {
-        Self(TR::zero(), Tn::zero())
+        Self(GLWE::<Tn<1>, K>::zero())
     }
 
-    pub fn new_key(mut rng: impl Rng) -> Result<(SecretKey<K>, PublicKey<K>)> {
-        let Xi_key = Uniform::new(0_f64, 2_f64);
-        let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
-
-        let s: TR<Tn<1>, K> = TR::rand(&mut rng, Xi_key);
-        let a: TR<Tn<1>, K> = TR::rand(&mut rng, Standard);
-        let e = Tn::rand(&mut rng, Xi_err);
-
-        let pk: PublicKey<K> = PublicKey((&a * &s) + e, a);
-        Ok((SecretKey(s), pk))
+    pub fn new_key(rng: impl Rng) -> Result<(SecretKey<K>, PublicKey<K>)> {
+        let (sk, pk) = GLWE::new_key(rng)?;
+        Ok((SecretKey(sk), PublicKey(pk)))
     }
 
     pub fn encode<const P: u64>(m: &Rq<P, 1>) -> Tn<1> {
@@ -47,50 +41,28 @@ impl TLWE {
     }
 
     // encrypts with the given SecretKey (instead of PublicKey)
-    pub fn encrypt_s(mut rng: impl Rng, sk: &SecretKey<K>, m: &Tn<1>) -> Result<Self> {
-        let Xi_key = Uniform::new(0_f64, 2_f64);
-        let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
-
-        let a: TR<Tn<1>, K> = TR::rand(&mut rng, Xi_key);
-        let e = Tn::rand(&mut rng, Xi_err);
-
-        let b: Tn<1> = (&a * &sk.0) + *m + e;
-        Ok(Self(a, b))
+    pub fn encrypt_s(rng: impl Rng, sk: &SecretKey<K>, p: &Tn<1>) -> Result<Self> {
+        let glwe = GLWE::encrypt_s(rng, &sk.0, p)?;
+        Ok(Self(glwe))
     }
-    pub fn encrypt(mut rng: impl Rng, pk: &PublicKey<K>, m: &Tn<1>) -> Result<Self> {
-        let Xi_key = Uniform::new(0_f64, 2_f64);
-        let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
-
-        let u: Tn<1> = Tn::rand(&mut rng, Xi_key);
-
-        let e0: Tn<1> = Tn::rand(&mut rng, Xi_err);
-        let e1 = TR::<Tn<1>, K>::rand(&mut rng, Xi_err);
-
-        let b: Tn<1> = pk.0 * u + *m + e0;
-        let d: TR<Tn<1>, K> = &pk.1 * &u + e1;
-
-        Ok(Self(d, b))
+    pub fn encrypt(rng: impl Rng, pk: &PublicKey<K>, p: &Tn<1>) -> Result<Self> {
+        let glwe = GLWE::encrypt(rng, &pk.0, p)?;
+        Ok(Self(glwe))
     }
     pub fn decrypt(&self, sk: &SecretKey<K>) -> Tn<1> {
-        let (d, b): (TR<Tn<1>, K>, Tn<1>) = (self.0.clone(), self.1);
-        b - &d * &sk.0
+        self.0.decrypt(&sk.0)
     }
 }
 
 impl<const K: usize> Add<TLWE<K>> for TLWE<K> {
     type Output = Self;
     fn add(self, other: Self) -> Self {
-        let a: TR<Tn<1>, K> = self.0 + other.0;
-        let b: Tn<1> = self.1 + other.1;
-        Self(a, b)
+        Self(self.0 + other.0)
     }
 }
 impl<const K: usize> AddAssign for TLWE<K> {
     fn add_assign(&mut self, rhs: Self) {
-        for i in 0..K {
-            self.0 .0[i] = self.0 .0[i] + rhs.0 .0[i];
-        }
-        self.1 = self.1 + rhs.1;
+        self.0 += rhs.0
     }
 }
 impl<const K: usize> Sum<TLWE<K>> for TLWE<K> {
@@ -109,9 +81,7 @@ impl Sum> for TLWE {
 impl<const K: usize> Sub<TLWE<K>> for TLWE<K> {
     type Output = Self;
     fn sub(self, other: Self) -> Self {
-        let a: TR<Tn<1>, K> = self.0 - other.0;
-        let b: Tn<1> = self.1 - other.1;
-        Self(a, b)
+        Self(self.0 - other.0)
     }
 }
 
@@ -119,27 +89,27 @@ impl Sub> for TLWE {
 impl<const K: usize> Add<Tn<1>> for TLWE<K> {
     type Output = Self;
     fn add(self, plaintext: Tn<1>) -> Self {
-        let a: TR<Tn<1>, K> = self.0;
-        let b: Tn<1> = self.1 + plaintext;
-        Self(a, b)
+        let a: TR<Tn<1>, K> = self.0 .0;
+        let b: Tn<1> = self.0 .1 + plaintext;
+        Self(GLWE(a, b))
     }
 }
 // plaintext substraction
 impl<const K: usize> Sub<Tn<1>> for TLWE<K> {
     type Output = Self;
     fn sub(self, plaintext: Tn<1>) -> Self {
-        let a: TR<Tn<1>, K> = self.0;
-        let b: Tn<1> = self.1 - plaintext;
-        Self(a, b)
+        let a: TR<Tn<1>, K> = self.0 .0;
+        let b: Tn<1> = self.0 .1 - plaintext;
+        Self(GLWE(a, b))
     }
 }
 // plaintext multiplication
 impl<const K: usize> Mul<Tn<1>> for TLWE<K> {
     type Output = Self;
     fn mul(self, plaintext: Tn<1>) -> Self {
-        let a: TR<Tn<1>, K> = TR(self.0 .0.iter().map(|r_i| *r_i * plaintext).collect());
-        let b: Tn<1> = self.1 * plaintext;
-        Self(a, b)
+        let a: TR<Tn<1>, K> = TR(self.0 .0 .0.iter().map(|r_i| *r_i * plaintext).collect());
+        let b: Tn<1> = self.0 .1 * plaintext;
+        Self(GLWE(a, b))
     }
 }
 
@@ -157,11 +127,11 @@ mod tests {
         type S = TLWE<K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
             dbg!(&m);
             let p: Tn<1> = S::encode::<T>(&m);
@@ -191,11 +161,11 @@ mod tests {
         type S = TLWE<K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
             let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
             let p1: Tn<1> = S::encode::<T>(&m1); // plaintext
@@ -222,11 +192,11 @@ mod tests {
         type S = TLWE<K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
             let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
             let p1: Tn<1> = S::encode::<T>(&m1); // plaintext
@@ -252,11 +222,11 @@ mod tests {
         type S = TLWE<K>;
 
         let mut rng = rand::thread_rng();
+        let msg_dist = Uniform::new(0_u64, T);
 
         for _ in 0..200 {
             let (sk, pk) = S::new_key(&mut rng)?;
 
-            let msg_dist = Uniform::new(0_u64, T);
             let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
             let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
             let p1: Tn<1> = S::encode::<T>(&m1);