lilium-sumcheck 0.1.0

generic Sumcheck implementation for Lilium
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

use crate::{
    barycentric_eval::BarycentricWeights,
    message::Message,
    sumcheck::{Sum, SumcheckFunction, SumcheckProver},
    symbolic::sumcheck_eval::SumcheckEvaluator,
};
use ark_ff::Field;
use transcript::params::ParamResolver;

mod prover;
mod reduction;
#[cfg(test)]
mod tests;
pub mod utils;
#[cfg(test)]
mod zerocheck;
mod zerofold;

pub use prover::SumFoldProverOutput;
pub use zerofold::ZeroFold;

/// Reduction from 2 folding instances into a single one.
pub struct SumFold<F: Field, SF: SumcheckFunction<F>> {
    // Weights for degree d.
    weights: BarycentricWeights<F>,
    // Weights for degree d + 1.
    extended_weights: BarycentricWeights<F>,
    degree: usize,
    evaluator: SumcheckEvaluator<F, SF>,
}

impl<F: Field, SF: SumcheckFunction<F>> SumFold<F, SF> {
    pub fn new(f: &SF) -> Self {
        let degree = SumcheckProver::<F, SF>::degree_symbolic(f);
        Self::new_custom_degree(degree, f)
    }

    pub(super) fn new_custom_degree(degree: usize, f: &SF) -> Self {
        let evaluator = SumcheckEvaluator::new(Some(f));
        let weights = BarycentricWeights::compute(degree as u32);
        let extended_weights = BarycentricWeights::compute(degree as u32 + 1);
        Self {
            weights,
            extended_weights,
            degree,
            evaluator,
        }
    }
}

pub struct SumFoldProof<F: Field> {
    message: Message<F>,
}

pub struct SumFoldInstance<F, const N: usize> {
    sums: [Sum<F>; N],
}

impl<F, const N: usize> SumFoldInstance<F, N> {
    pub fn new(sums: [F; N]) -> Self {
        let sums = sums.map(Sum);
        Self { sums }
    }
}

impl<F: Field, const N: usize> transcript::Message<F> for SumFoldInstance<F, N> {
    fn len(vars: usize, param_resolver: &ParamResolver) -> usize {
        <[Sum<F>; N] as transcript::Message<F>>::len(vars, param_resolver)
    }

    fn to_field_elements(&self) -> Vec<F> {
        self.sums.to_field_elements()
    }
}