poulpy-core 0.6.0

A backend-agnostic crate implementing Module-LWE-based encryption and arithmetic
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Reference implementations of the [`GGLWEExternalProductDefault`] methods.
//!
//! Re-exported publicly through `crate::oep::gglwe_external_product_defaults`.

#![allow(private_bounds)]

use poulpy_hal::layouts::{Backend, ScratchArena};

use crate::{
    default::operations::GLWEZeroDefault,
    layouts::{GGLWEInfos, GGLWEToBackendMut, GGLWEToBackendRef, GGSWInfos, GLWEViewMut, prepared::GGSWPreparedToBackendRef},
    oep::{GGLWEExternalProductDefault, GLWEExternalProductDefault},
};

pub fn gglwe_external_product_tmp_bytes_default<BE, M, R, A, B>(module: &M, res_infos: &R, a_infos: &A, b_infos: &B) -> usize
where
    BE: Backend,
    M: GLWEExternalProductDefault<BE>,
    R: GGLWEInfos,
    A: GGLWEInfos,
    B: GGSWInfos,
{
    module.glwe_external_product_tmp_bytes_default(res_infos, a_infos, b_infos)
}

pub fn gglwe_external_product_default<BE, M, R, A, B>(
    module: &M,
    res: &mut R,
    a: &A,
    b: &B,
    key_size: usize,
    scratch: &mut ScratchArena<'_, BE>,
) where
    BE: Backend,
    M: GGLWEExternalProductDefault<BE> + GLWEExternalProductDefault<BE> + GLWEZeroDefault<BE>,
    R: GGLWEToBackendMut<BE> + GGLWEInfos,
    A: GGLWEToBackendRef<BE> + GGLWEInfos,
    B: GGSWPreparedToBackendRef<BE> + GGSWInfos,
{
    assert_eq!(
        res.rank_in(),
        a.rank_in(),
        "res input rank_in: {} != a input rank_in: {}",
        res.rank_in(),
        a.rank_in()
    );
    assert_eq!(
        a.rank_out(),
        b.rank(),
        "a output rank_out: {} != b rank: {}",
        a.rank_out(),
        b.rank()
    );
    assert_eq!(
        res.rank_out(),
        b.rank(),
        "res output rank_out: {} != b rank: {}",
        res.rank_out(),
        b.rank()
    );
    assert_eq!(res.base2k(), a.base2k());
    assert!(
        scratch.available() >= module.gglwe_external_product_tmp_bytes_default(res, a, b),
        "scratch.available(): {} < GGLWEExternalProduct::gglwe_external_product_tmp_bytes: {}",
        scratch.available(),
        module.gglwe_external_product_tmp_bytes_default(res, a, b)
    );

    let min_dnum: usize = res.dnum().min(a.dnum()).into();
    let res_dnum: usize = res.dnum().into();
    let res_rank_in: usize = res.rank_in().into();
    {
        let mut res = res.to_backend_mut();
        let a = a.to_backend_ref();
        for row in 0..min_dnum {
            for col in 0..res_rank_in {
                let mut res_at = res.at_view_mut(row, col);
                let a_at = a.at_view(row, col);
                module.glwe_external_product_default(&mut res_at, &a_at, b, key_size, &mut scratch.borrow());
            }
        }
    }

    if min_dnum < res_dnum {
        let mut res = res.to_backend_mut();
        for row in min_dnum..res_dnum {
            for col in 0..res_rank_in {
                let mut ct: GLWEViewMut<'_, BE> = res.at_view_mut(row, col);
                module.glwe_zero_default(&mut ct);
            }
        }
    }
}

pub fn gglwe_external_product_assign_default<BE, M, R, A>(
    module: &M,
    res: &mut R,
    a: &A,
    key_size: usize,
    scratch: &mut ScratchArena<'_, BE>,
) where
    BE: Backend,
    M: GGLWEExternalProductDefault<BE> + GLWEExternalProductDefault<BE>,
    R: GGLWEToBackendMut<BE> + GGLWEInfos,
    A: GGSWPreparedToBackendRef<BE> + GGSWInfos,
{
    assert_eq!(
        res.rank_out(),
        a.rank(),
        "res output rank: {} != a rank: {}",
        res.rank_out(),
        a.rank()
    );
    assert!(
        scratch.available() >= module.gglwe_external_product_tmp_bytes_default(res, res, a),
        "scratch.available(): {} < GGLWEExternalProduct::gglwe_external_product_tmp_bytes: {}",
        scratch.available(),
        module.gglwe_external_product_tmp_bytes_default(res, res, a)
    );

    let res_dnum: usize = res.dnum().into();
    let res_rank_in: usize = res.rank_in().into();
    let mut res = res.to_backend_mut();
    for row in 0..res_dnum {
        for col in 0..res_rank_in {
            let mut res_at = res.at_view_mut(row, col);
            module.glwe_external_product_assign_default(&mut res_at, a, key_size, &mut scratch.borrow());
        }
    }
}