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