zksync_bellman 0.32.10

zk-SNARK library, based on bellman
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

use crate::pairing::ff::PrimeField;

use crate::plonk::domains::Domain;
use crate::worker::Worker;
use crate::plonk::fft::distribute_powers;
use crate::plonk::fft::with_precomputation::FftPrecomputations;

pub struct PrecomputedOmegas<F: PrimeField> {
    pub omegas: Vec<F>,
    pub coset: Vec<F>,
    pub omegas_inv: Vec<F>,
    domain_size: usize
}

impl<F: PrimeField> PrecomputedOmegas<F> {
    pub fn new_for_domain(domain: &Domain<F>, worker: &Worker) -> Self {
        let domain_size = domain.size as usize;

        let omega = domain.generator;
        let omega_inv = domain.generator.inverse().expect("must exist");

        let mut omegas = vec![F::zero(); domain_size];
        let mut omegas_inv = vec![F::zero(); domain_size];

        worker.scope(omegas.len(), |scope, chunk| {
            for (i, v) in omegas.chunks_mut(chunk).enumerate() {
                scope.spawn(move |_| {
                    let mut u = omega.pow(&[(i * chunk) as u64]);
                    for v in v.iter_mut() {
                        *v = u;
                        u.mul_assign(&omega);
                    }
                });
            }
        });

        worker.scope(omegas_inv.len(), |scope, chunk| {
            for (i, v) in omegas_inv.chunks_mut(chunk).enumerate() {
                scope.spawn(move |_| {
                    let mut u = omega_inv.pow(&[(i * chunk) as u64]);
                    for v in v.iter_mut() {
                        *v = u;
                        u.mul_assign(&omega_inv);
                    }
                });
            }
        });

        let mut coset = omegas.clone();
        let mult_generator = F::multiplicative_generator();

        worker.scope(coset.len(), |scope, chunk| {
            for v in coset.chunks_mut(chunk) {
                scope.spawn(move |_| {
                    for v in v.iter_mut() {
                        v.mul_assign(&mult_generator);
                    }
                });
            }
        });

        PrecomputedOmegas{
            omegas,
            coset,
            omegas_inv,
            domain_size
        }
    }
}

pub struct PrecomputedInvOmegasHalfSize<F: PrimeField> {
    pub omegas_inv: Vec<F>,
    domain_size: usize
}

impl<F: PrimeField> PrecomputedInvOmegasHalfSize<F> {
    pub fn new_for_domain(domain: &Domain<F>, worker: &Worker) -> Self {
        let domain_size = domain.size as usize;
        let precomputation_size = domain_size/2;

        let omega = domain.generator;
        let omega_inv = omega.inverse().expect("must exist");

        let mut omegas_inv = vec![F::zero(); precomputation_size];

        worker.scope(omegas_inv.len(), |scope, chunk| {
            for (i, v) in omegas_inv.chunks_mut(chunk).enumerate() {
                scope.spawn(move |_| {
                    let mut u = omega_inv.pow(&[(i * chunk) as u64]);
                    for v in v.iter_mut() {
                        *v = u;
                        u.mul_assign(&omega_inv);
                    }
                });
            }
        });

        PrecomputedInvOmegas{
            omegas_inv,
            domain_size
        }
    }
}