arcium-primitives 0.4.5

Arcium primitives
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

use crate::{
    algebra::field::FieldExtension,
    correlated_randomness::singlets::types::{Singlet, Singlets},
    random::{CryptoRngCore, Random, RandomWith},
    sharing::{FieldShare, FieldShares, GlobalFieldKey},
    types::Positive,
    utils::IntoExactSizeIterator,
};
// -------------------------
// |   Random Generation   |
// -------------------------

impl<F: FieldExtension> Random for Singlet<F> {
    /// UNIMPLEMENTED: Singlets are correlated randomness, use `random_n`/`random_n_with`` to
    /// establish correlation for `n_parties`.
    fn random(_rng: impl CryptoRngCore) -> Self {
        unimplemented!("Singlets are correlated randomness. Use `random_n`/`random_n_with`` to establish correlation for n_parties")
    }

    /// Generates a vector of random singlets, one for each party.
    fn random_n<Container: FromIterator<Self>>(
        source: impl CryptoRngCore,
        size: usize,
    ) -> Container {
        FieldShare::random_n::<Vec<_>>(source, size)
            .into_iter()
            .map(Singlet)
            .collect()
    }
}

impl<F: FieldExtension, M: Positive> Random for Singlets<F, M> {
    /// UNIMPLEMENTED: Singlets are correlated randomness, use `random_n`/`random_n_with`` to
    /// establish correlation for `n_parties`.
    fn random(_rng: impl CryptoRngCore) -> Self {
        unimplemented!("Singlets are correlated randomness. Use `random_n`/`random_n_with`` to establish correlation for n_parties")
    }

    /// Generates a vector of random singlets, one for each party.
    fn random_n<Container: FromIterator<Self>>(
        source: impl CryptoRngCore,
        size: usize,
    ) -> Container {
        FieldShares::<F, M>::random_n::<Vec<_>>(source, size)
            .into_iter()
            .map(Singlets)
            .collect()
    }
}

impl<F: FieldExtension, M: Positive> RandomWith<usize> for Singlets<F, M> {
    fn random_with(mut rng: impl CryptoRngCore, n_parties: usize) -> Self {
        Singlets(FieldShares::<F, M>::random_with(&mut rng, n_parties))
    }
}

impl<F: FieldExtension, M: Positive> RandomWith<Vec<GlobalFieldKey<F>>> for Singlets<F, M> {
    fn random_with(_rng: impl CryptoRngCore, _alphas: Vec<GlobalFieldKey<F>>) -> Self {
        unimplemented!("Singlets are correlated randomness. Use `random_vec_with`/`random_box_with` to establish correlation for n_parties")
    }

    /// Generates a vector of random singlets, one for each party, using the provided alphas.
    fn random_n_with_each<Container: FromIterator<Self>>(
        rng: impl CryptoRngCore,
        all_alphas: impl IntoExactSizeIterator<Item = Vec<GlobalFieldKey<F>>>,
    ) -> Container {
        FieldShares::<F, M>::random_n_with_each::<Vec<_>>(rng, all_alphas)
            .into_iter()
            .map(Singlets)
            .collect()
    }
}