1use std::collections::HashMap;
  2
  3use backend::{FFT64, FillUniform, Module, ScratchOwned, Stats, VecZnxOps, ZnxView, ZnxViewMut};
  4use sampling::source::Source;
  5
  6use crate::{
  7    FourierGLWESecret, GLWEAutomorphismKey, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos,
  8    noise::var_noise_gglwe_product,
  9};
 10
 11#[test]
 12fn apply_inplace() {
 13    let log_n: usize = 8;
 14    (1..4).for_each(|rank| {
 15        println!("test trace_inplace rank: {}", rank);
 16        test_trace_inplace(log_n, 8, 54, 3.2, rank);
 17    });
 18}
 19
 20fn test_trace_inplace(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize) {
 21    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 22
 23    let k_autokey: usize = k + basek;
 24
 25    let digits: usize = 1;
 26    let rows: usize = k.div_ceil(basek * digits);
 27
 28    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k, rank);
 29    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&module, basek, k);
 30    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&module, basek, k);
 31
 32    let mut source_xs: Source = Source::new([0u8; 32]);
 33    let mut source_xe: Source = Source::new([0u8; 32]);
 34    let mut source_xa: Source = Source::new([0u8; 32]);
 35
 36    let mut scratch: ScratchOwned = ScratchOwned::new(
 37        GLWECiphertext::encrypt_sk_scratch_space(&module, basek, ct.k())
 38            | GLWECiphertext::decrypt_scratch_space(&module, basek, ct.k())
 39            | GLWEAutomorphismKey::generate_from_sk_scratch_space(&module, basek, k_autokey, rank)
 40            | GLWECiphertext::trace_inplace_scratch_space(&module, basek, ct.k(), k_autokey, digits, rank),
 41    );
 42
 43    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(&module, rank);
 44    sk.fill_ternary_prob(0.5, &mut source_xs);
 45    let sk_dft: FourierGLWESecret<Vec<u8>, FFT64> = FourierGLWESecret::from(&module, &sk);
 46
 47    let mut data_want: Vec<i64> = vec![0i64; module.n()];
 48
 49    data_want
 50        .iter_mut()
 51        .for_each(|x| *x = source_xa.next_i64() & 0xFF);
 52
 53    pt_have
 54        .data
 55        .fill_uniform(basek, 0, pt_have.size(), &mut source_xa);
 56
 57    ct.encrypt_sk(
 58        &module,
 59        &pt_have,
 60        &sk_dft,
 61        &mut source_xa,
 62        &mut source_xe,
 63        sigma,
 64        scratch.borrow(),
 65    );
 66
 67    let mut auto_keys: HashMap<i64, GLWEAutomorphismKey<Vec<u8>, FFT64>> = HashMap::new();
 68    let gal_els: Vec<i64> = GLWECiphertext::trace_galois_elements(&module);
 69    gal_els.iter().for_each(|gal_el| {
 70        let mut key: GLWEAutomorphismKey<Vec<u8>, FFT64> =
 71            GLWEAutomorphismKey::alloc(&module, basek, k_autokey, rows, digits, rank);
 72        key.generate_from_sk(
 73            &module,
 74            *gal_el,
 75            &sk,
 76            &mut source_xa,
 77            &mut source_xe,
 78            sigma,
 79            scratch.borrow(),
 80        );
 81        auto_keys.insert(*gal_el, key);
 82    });
 83
 84    ct.trace_inplace(&module, 0, 5, &auto_keys, scratch.borrow());
 85    ct.trace_inplace(&module, 5, log_n, &auto_keys, scratch.borrow());
 86
 87    (0..pt_want.size()).for_each(|i| pt_want.data.at_mut(0, i)[0] = pt_have.data.at(0, i)[0]);
 88
 89    ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow());
 90
 91    module.vec_znx_sub_ab_inplace(&mut pt_want.data, 0, &pt_have.data, 0);
 92    module.vec_znx_normalize_inplace(basek, &mut pt_want.data, 0, scratch.borrow());
 93
 94    let noise_have = pt_want.data.std(0, basek).log2();
 95
 96    let mut noise_want: f64 = var_noise_gglwe_product(
 97        module.n() as f64,
 98        basek,
 99        0.5,
100        0.5,
101        1.0 / 12.0,
102        sigma * sigma,
103        0.0,
104        rank as f64,
105        k,
106        k_autokey,
107    );
108    noise_want += sigma * sigma * (-2.0 * (k) as f64).exp2();
109    noise_want += module.n() as f64 * 1.0 / 12.0 * 0.5 * rank as f64 * (-2.0 * (k) as f64).exp2();
110    noise_want = noise_want.sqrt().log2();
111
112    assert!(
113        (noise_have - noise_want).abs() < 1.0,
114        "{} > {}",
115        noise_have,
116        noise_want
117    );
118}