fflonk 0.32.10

Reference implementation of fflonk prover and verifier
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

use super::*;

#[derive(serde::Serialize)]
pub struct LookupMonomials<F: PrimeField> {
    pub s_poly_monomial: Polynomial<F, Coefficients>,
    pub grand_product_monomial: Polynomial<F, Coefficients>,
    pub first_quotient: Polynomial<F, Coefficients>,
    pub second_quotient: Polynomial<F, Coefficients>,
    pub third_quotient: Polynomial<F, Coefficients>,
}

impl<F: PrimeField> LookupMonomials<F> {
    pub fn flatten(&self) -> Vec<&Polynomial<F, Coefficients>> {
        let mut flattened = vec![];

        flattened.push(&self.s_poly_monomial);
        flattened.push(&self.grand_product_monomial);
        flattened.push(&self.first_quotient);
        flattened.push(&self.second_quotient);
        flattened.push(&self.third_quotient);

        flattened
    }
}

#[derive(Default, Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
#[serde(bound = "")]
pub struct LookupEvaluations<F: PrimeField> {
    pub s_poly_at_z: F,
    pub s_poly_at_z_omega: F,
    pub grand_product_at_z: F,
    pub grand_product_at_z_omega: F,
    pub first_quotient_at_z_omega: F,
    pub second_quotient_at_z_omega: F,
    pub third_quotient_at_z_omega: F,
}

#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
pub struct LookupEvaluationOffsets {
    pub s_poly_at_z: usize,
    pub s_poly_at_z_omega: usize,
    pub grand_product_at_z: usize,
    pub grand_product_at_z_omega: usize,
    pub first_quotient_at_z_omega: usize,
    pub second_quotient_at_z_omega: usize,
    pub third_quotient_at_z_omega: usize,
}
impl<F: PrimeField> Flatten<F> for LookupEvaluations<F> {
    fn flatten(&self) -> (Vec<F>, Vec<F>) {
        let mut evals = vec![];
        let mut shifted_evals = vec![];
        evals.push(self.s_poly_at_z);
        shifted_evals.push(self.s_poly_at_z_omega);
        evals.push(self.grand_product_at_z);
        shifted_evals.push(self.grand_product_at_z_omega);
        shifted_evals.push(self.first_quotient_at_z_omega);
        shifted_evals.push(self.second_quotient_at_z_omega);
        shifted_evals.push(self.third_quotient_at_z_omega);
        assert_eq!(evals.len() + 3, shifted_evals.len());

        (evals, shifted_evals)
    }
}

pub fn evaluate_lookup_monomials<'a, F: PrimeField>(worker: &Worker, monomials_storage: &LookupMonomials<F>, z: F, z_omega: F) -> LookupEvaluations<F> {
    let s_poly_at_z = monomials_storage.s_poly_monomial.evaluate_at(worker, z);
    let s_poly_at_z_omega = monomials_storage.s_poly_monomial.evaluate_at(worker, z_omega);

    let grand_product_at_z = monomials_storage.grand_product_monomial.evaluate_at(worker, z);
    let grand_product_at_z_omega = monomials_storage.grand_product_monomial.evaluate_at(worker, z_omega);

    let first_quotient_at_z_omega = monomials_storage.first_quotient.evaluate_at(worker, z_omega);
    let second_quotient_at_z_omega = monomials_storage.second_quotient.evaluate_at(worker, z_omega);
    let third_quotient_at_z_omega = monomials_storage.third_quotient.evaluate_at(worker, z_omega);

    LookupEvaluations {
        s_poly_at_z,
        s_poly_at_z_omega,
        grand_product_at_z,
        grand_product_at_z_omega,
        first_quotient_at_z_omega,
        third_quotient_at_z_omega,
        second_quotient_at_z_omega,
    }
}