1use std::collections::HashMap;
  2
  3use backend::hal::{
  4    api::{
  5        ScratchOwnedAlloc, ScratchOwnedBorrow, VecZnxAddScalarInplace, VecZnxAutomorphism, VecZnxBigAutomorphismInplace,
  6        VecZnxBigSubSmallBInplace, VecZnxCopy, VecZnxFillUniform, VecZnxNormalizeInplace, VecZnxRotateInplace, VecZnxRshInplace,
  7        VecZnxSubABInplace, VecZnxSwithcDegree, VmpPMatAlloc, VmpPMatPrepare, ZnxView, ZnxViewMut,
  8    },
  9    layouts::{Backend, Module, ScratchOwned},
 10    oep::{
 11        ScratchAvailableImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeScalarZnxImpl, TakeSvpPPolImpl,
 12        TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxImpl,
 13    },
 14};
 15use sampling::source::Source;
 16
 17use crate::{
 18    layouts::{
 19        GGLWEAutomorphismKey, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos,
 20        prepared::{GGLWEAutomorphismKeyPrepared, GLWESecretPrepared, PrepareAlloc},
 21    },
 22    noise::var_noise_gglwe_product,
 23    trait_families::{GLWEDecryptFamily, GLWEKeyswitchFamily},
 24};
 25
 26use crate::trait_families::{GGLWESwitchingKeyEncryptSkFamily, GLWESecretPreparedModuleFamily};
 27
 28pub trait TraceTestModuleFamily<B: Backend> = GGLWESwitchingKeyEncryptSkFamily<B>
 29    + GLWESecretPreparedModuleFamily<B>
 30    + GLWEKeyswitchFamily<B>
 31    + GLWEDecryptFamily<B>
 32    + VecZnxSwithcDegree
 33    + VecZnxAddScalarInplace
 34    + VecZnxRotateInplace
 35    + VecZnxBigSubSmallBInplace<B>
 36    + VecZnxBigAutomorphismInplace<B>
 37    + VecZnxCopy
 38    + VecZnxAutomorphism
 39    + VecZnxRshInplace
 40    + VmpPMatAlloc<B>
 41    + VmpPMatPrepare<B>;
 42
 43pub trait TraceTestScratchFamily<B: Backend> = TakeVecZnxDftImpl<B>
 44    + TakeVecZnxBigImpl<B>
 45    + TakeSvpPPolImpl<B>
 46    + ScratchOwnedAllocImpl<B>
 47    + ScratchOwnedBorrowImpl<B>
 48    + ScratchAvailableImpl<B>
 49    + TakeScalarZnxImpl<B>
 50    + TakeVecZnxImpl<B>;
 51
 52pub fn test_glwe_trace_inplace<B: Backend>(module: &Module<B>, basek: usize, k: usize, sigma: f64, rank: usize)
 53where
 54    Module<B>: TraceTestModuleFamily<B>,
 55    B: TraceTestScratchFamily<B>,
 56{
 57    let n: usize = module.n();
 58    let k_autokey: usize = k + basek;
 59
 60    let digits: usize = 1;
 61    let rows: usize = k.div_ceil(basek * digits);
 62
 63    let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k, rank);
 64    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k);
 65    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(n, basek, k);
 66
 67    let mut source_xs: Source = Source::new([0u8; 32]);
 68    let mut source_xe: Source = Source::new([0u8; 32]);
 69    let mut source_xa: Source = Source::new([0u8; 32]);
 70
 71    let mut scratch: ScratchOwned<B> = ScratchOwned::alloc(
 72        GLWECiphertext::encrypt_sk_scratch_space(module, n, basek, ct.k())
 73            | GLWECiphertext::decrypt_scratch_space(module, n, basek, ct.k())
 74            | GGLWEAutomorphismKey::encrypt_sk_scratch_space(module, n, basek, k_autokey, rank)
 75            | GLWECiphertext::trace_inplace_scratch_space(module, n, basek, ct.k(), k_autokey, digits, rank),
 76    );
 77
 78    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
 79    sk.fill_ternary_prob(0.5, &mut source_xs);
 80    let sk_dft: GLWESecretPrepared<Vec<u8>, B> = sk.prepare_alloc(module, scratch.borrow());
 81
 82    let mut data_want: Vec<i64> = vec![0i64; n];
 83
 84    data_want
 85        .iter_mut()
 86        .for_each(|x| *x = source_xa.next_i64() & 0xFF);
 87
 88    module.vec_znx_fill_uniform(basek, &mut pt_have.data, 0, k, &mut source_xa);
 89
 90    ct.encrypt_sk(
 91        module,
 92        &pt_have,
 93        &sk_dft,
 94        &mut source_xa,
 95        &mut source_xe,
 96        sigma,
 97        scratch.borrow(),
 98    );
 99
100    let mut auto_keys: HashMap<i64, GGLWEAutomorphismKeyPrepared<Vec<u8>, B>> = HashMap::new();
101    let gal_els: Vec<i64> = GLWECiphertext::trace_galois_elements(module);
102    let mut tmp: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_autokey, rows, digits, rank);
103    gal_els.iter().for_each(|gal_el| {
104        tmp.encrypt_sk(
105            module,
106            *gal_el,
107            &sk,
108            &mut source_xa,
109            &mut source_xe,
110            sigma,
111            scratch.borrow(),
112        );
113        let atk_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, B> = tmp.prepare_alloc(module, scratch.borrow());
114        auto_keys.insert(*gal_el, atk_prepared);
115    });
116
117    ct.trace_inplace(module, 0, 5, &auto_keys, scratch.borrow());
118    ct.trace_inplace(module, 5, module.log_n(), &auto_keys, scratch.borrow());
119
120    (0..pt_want.size()).for_each(|i| pt_want.data.at_mut(0, i)[0] = pt_have.data.at(0, i)[0]);
121
122    ct.decrypt(module, &mut pt_have, &sk_dft, scratch.borrow());
123
124    module.vec_znx_sub_ab_inplace(&mut pt_want.data, 0, &pt_have.data, 0);
125    module.vec_znx_normalize_inplace(basek, &mut pt_want.data, 0, scratch.borrow());
126
127    let noise_have: f64 = pt_want.std().log2();
128
129    let mut noise_want: f64 = var_noise_gglwe_product(
130        n as f64,
131        basek,
132        0.5,
133        0.5,
134        1.0 / 12.0,
135        sigma * sigma,
136        0.0,
137        rank as f64,
138        k,
139        k_autokey,
140    );
141    noise_want += sigma * sigma * (-2.0 * (k) as f64).exp2();
142    noise_want += n as f64 * 1.0 / 12.0 * 0.5 * rank as f64 * (-2.0 * (k) as f64).exp2();
143    noise_want = noise_want.sqrt().log2();
144
145    assert!(
146        (noise_have - noise_want).abs() < 1.0,
147        "{} > {}",
148        noise_have,
149        noise_want
150    );
151}