moose 0.2.2

Encrypted learning and data processing framework
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::*;

/// Exclusive-or
pub trait PlacementXor<S: Session, T, U, O> {
    fn xor(&self, sess: &S, x: &T, y: &U) -> O;
}

modelled_kernel! {
    PlacementXor::xor, XorOp,
    [
        (HostPlacement, (HostBitTensor, HostBitTensor) -> HostBitTensor => [runtime] Self::host_kernel),
        (ReplicatedPlacement, (ReplicatedBitTensor, ReplicatedBitTensor) -> ReplicatedBitTensor => [transparent] Self::rep_kernel),
        (ReplicatedPlacement, (Mirrored3BitTensor, ReplicatedBitTensor) -> ReplicatedBitTensor => [transparent] Self::rep_kernel),
        (ReplicatedPlacement, (ReplicatedBitTensor, Mirrored3BitTensor) -> ReplicatedBitTensor => [transparent] Self::rep_kernel),
    ]
}

// add = xor in Z2
impl<S: Session> PlacementAdd<S, m!(HostBitTensor), m!(HostBitTensor), m!(HostBitTensor)>
    for HostPlacement
where
    HostBitTensor: KnownType<S>,
    HostPlacement: PlacementXor<S, m!(HostBitTensor), m!(HostBitTensor), m!(HostBitTensor)>,
{
    fn add(&self, sess: &S, x0: &m!(HostBitTensor), x1: &m!(HostBitTensor)) -> m!(HostBitTensor) {
        self.xor(sess, x0, x1)
    }
}

// sub = xor in Z2
impl<S: Session> PlacementSub<S, m!(HostBitTensor), m!(HostBitTensor), m!(HostBitTensor)>
    for HostPlacement
where
    HostBitTensor: KnownType<S>,
    HostPlacement: PlacementXor<S, m!(HostBitTensor), m!(HostBitTensor), m!(HostBitTensor)>,
{
    fn sub(&self, sess: &S, x0: &m!(HostBitTensor), x1: &m!(HostBitTensor)) -> m!(HostBitTensor) {
        self.xor(sess, x0, x1)
    }
}

/// Logical-and
pub trait PlacementAnd<S: Session, T, U, O> {
    fn and(&self, sess: &S, x: &T, y: &U) -> O;
}

modelled_kernel! {
    PlacementAnd::and, AndOp,
    [
        (HostPlacement, (HostBitTensor, HostBitTensor) -> HostBitTensor => [runtime] Self::host_kernel),
        (HostPlacement, (HostRing64Tensor, HostRing64Tensor) -> HostRing64Tensor => [runtime] Self::host_ring_kernel),
        (HostPlacement, (HostRing128Tensor, HostRing128Tensor) -> HostRing128Tensor => [runtime] Self::host_ring_kernel),
        (ReplicatedPlacement, (ReplicatedBitTensor, ReplicatedBitTensor) -> ReplicatedBitTensor => [transparent] Self::rep_kernel),
    ]
}

// mul = and in Z2
impl<S: Session> PlacementMul<S, m!(HostBitTensor), m!(HostBitTensor), m!(HostBitTensor)>
    for HostPlacement
where
    HostBitTensor: KnownType<S>,
    HostPlacement: PlacementAnd<S, m!(HostBitTensor), m!(HostBitTensor), m!(HostBitTensor)>,
{
    fn mul(&self, sess: &S, x0: &m!(HostBitTensor), x1: &m!(HostBitTensor)) -> m!(HostBitTensor) {
        self.and(sess, x0, x1)
    }
}

/// Logical-or
pub trait PlacementOr<S: Session, T, U, O> {
    fn or(&self, sess: &S, x: &T, y: &U) -> O;
}

modelled_kernel! {
    PlacementOr::or, OrOp,
    [
        (HostPlacement, (Tensor, Tensor) -> Tensor => [concrete] Self::logical_host_kernel),
        (HostPlacement, (BooleanTensor, BooleanTensor) -> BooleanTensor => [concrete] Self::bool_kernel),
        (HostPlacement, (HostBitTensor, HostBitTensor) -> HostBitTensor => [runtime] Self::host_kernel),
    ]
}

pub trait PlacementMsb<S: Session, T, O> {
    fn msb(&self, sess: &S, x: &T) -> O;
}

modelled_kernel! {
    PlacementMsb::msb, MsbOp,
    [
        (ReplicatedPlacement,  (ReplicatedRing64Tensor) -> ReplicatedBitTensor => [transparent] Self::rep_bit_kernel),
        (ReplicatedPlacement,  (ReplicatedRing128Tensor) -> ReplicatedBitTensor => [transparent] Self::rep_bit_kernel),
        (ReplicatedPlacement,  (ReplicatedRing64Tensor) -> ReplicatedRing64Tensor => [transparent] Self::rep_ring_kernel),
        (ReplicatedPlacement,  (ReplicatedRing128Tensor) -> ReplicatedRing128Tensor => [transparent] Self::rep_ring_kernel),
        (ReplicatedPlacement,  (ReplicatedBitArray64) -> ReplicatedRing64Tensor => [transparent] Self::rep_bit_dec_kernel),
        (ReplicatedPlacement,  (ReplicatedBitArray128) -> ReplicatedRing128Tensor => [transparent] Self::rep_bit_dec_kernel),

    ]
}

pub trait PlacementBitExtract<S: Session, T, O> {
    fn bit_extract(&self, sess: &S, bit_idx: usize, x: &T) -> O;
}

modelled_kernel! {
    PlacementBitExtract::bit_extract, BitExtractOp{bit_idx: usize},
    [
        (HostPlacement, (HostRing64Tensor) -> HostBitTensor => [runtime] Self::kernel64),
        (HostPlacement, (HostRing128Tensor) -> HostBitTensor => [runtime] Self::kernel128),
    ]
}

pub trait PlacementBitDecompose<S: Session, T, O> {
    fn bit_decompose(&self, sess: &S, x: &T) -> O;
}

modelled_kernel! {
    PlacementBitDecompose::bit_decompose, BitDecomposeOp,
    [
        (HostPlacement, (HostRing64Tensor) -> HostRing64Tensor => [runtime] Self::host_ring64_kernel),
        (HostPlacement, (HostRing128Tensor) -> HostRing128Tensor => [runtime] Self::host_ring128_kernel),
        (HostPlacement, (HostRing64Tensor) -> HostBitTensor => [runtime] Self::host_bit64_kernel),
        (HostPlacement, (HostRing128Tensor) -> HostBitTensor => [runtime] Self::host_bit128_kernel),
        (ReplicatedPlacement, (ReplicatedRing64Tensor) -> ReplicatedBitArray64 => [hybrid] Self::rep_ring_kernel),
        (ReplicatedPlacement, (ReplicatedRing128Tensor) -> ReplicatedBitArray128 => [hybrid] Self::rep_ring_kernel),
    ]
}

pub trait PlacementBitCompose<S: Session, T, O> {
    fn bit_compose(&self, sess: &S, x: &T) -> O;
}

modelled_kernel! {
    PlacementBitCompose::bit_compose, BitComposeOp,
    [
        (ReplicatedPlacement, (ReplicatedBitArray64) -> ReplicatedRing64Tensor => [transparent] Self::rep_kernel),
        (ReplicatedPlacement, (ReplicatedBitArray128) -> ReplicatedRing128Tensor => [transparent] Self::rep_kernel),
    ]
}

pub trait PlacementRingInject<S: Session, T, O> {
    fn ring_inject(&self, sess: &S, bit_idx: usize, x: &T) -> O;
}

modelled_kernel! {
    PlacementRingInject::ring_inject, RingInjectOp{bit_idx: usize},
    [
        (HostPlacement, (HostBitTensor) -> HostRing64Tensor => [runtime] Self::host_kernel),
        (HostPlacement, (HostBitTensor) -> HostRing128Tensor => [runtime] Self::host_kernel),
        (ReplicatedPlacement, (ReplicatedBitTensor) -> ReplicatedRing64Tensor => [concrete] Self::rep_kernel),
        (ReplicatedPlacement, (ReplicatedBitTensor) -> ReplicatedRing128Tensor => [concrete] Self::rep_kernel),
    ]
}