slop-sumcheck 6.1.0

Sumcheck protocol implementation for multilinear polynomials
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

use slop_algebra::{Field, UnivariatePolynomial};
use slop_alloc::{Backend, HasBackend};

use crate::{ComponentPoly, SumcheckPoly, SumcheckPolyBase, SumcheckPolyFirstRound};

/// A trait to enable backend implementations of component polynomials.
///
/// An implementation of this trait for a type will imply a [crate::ComponentPoly] implementation
pub trait ComponentPolyEvalBackend<P, K>: Backend
where
    P: SumcheckPolyBase + HasBackend<Backend = Self>,
{
    fn get_component_poly_evals(poly: &P) -> Vec<K>;
}

impl<K, P> ComponentPoly<K> for P
where
    K: Field,
    P: SumcheckPolyBase + HasBackend + Sync,
    P::Backend: ComponentPolyEvalBackend<P, K>,
{
    #[inline]
    fn get_component_poly_evals(&self) -> Vec<K> {
        P::Backend::get_component_poly_evals(self)
    }
}

/// A trait to enable backend implementations of sumcheck polynomials for the first round.
///
/// An implementation of this trait for a type will imply a [crate::SumcheckPolyFirstRound]
/// implementation for that type.
pub trait SumCheckPolyFirstRoundBackend<P, K>: Backend
where
    K: Field,
    P: SumcheckPolyBase + HasBackend<Backend = Self>,
{
    type NextRoundPoly: SumcheckPoly<K>;
    fn fix_t_variables(poly: P, alpha: K, t: usize) -> Self::NextRoundPoly;

    fn sum_as_poly_in_last_t_variables(
        poly: &P,
        claim: Option<K>,
        t: usize,
    ) -> UnivariatePolynomial<K>;
}

impl<K, P> SumcheckPolyFirstRound<K> for P
where
    K: Field,
    P: SumcheckPolyBase + ComponentPoly<K> + HasBackend + Send + Sync,
    P::Backend: SumCheckPolyFirstRoundBackend<P, K>,
{
    type NextRoundPoly = <P::Backend as SumCheckPolyFirstRoundBackend<P, K>>::NextRoundPoly;
    #[inline]
    fn fix_t_variables(self, alpha: K, t: usize) -> Self::NextRoundPoly {
        P::Backend::fix_t_variables(self, alpha, t)
    }

    #[inline]
    fn sum_as_poly_in_last_t_variables(
        &self,
        claim: Option<K>,
        t: usize,
    ) -> UnivariatePolynomial<K> {
        P::Backend::sum_as_poly_in_last_t_variables(self, claim, t)
    }
}

/// A trait to enable backend implementations of sumcheck polynomials.
///
/// An implementation of this trait for a type will imply a [crate::SumcheckPoly] implementation
pub trait SumcheckPolyBackend<P, K>: Backend
where
    K: Field,
    P: SumcheckPolyBase + ComponentPoly<K> + HasBackend<Backend = Self>,
{
    fn fix_last_variable(poly: P, alpha: K) -> P;

    fn sum_as_poly_in_last_variable(poly: &P, claim: Option<K>) -> UnivariatePolynomial<K>;
}

impl<K, P> SumcheckPoly<K> for P
where
    K: Field,
    P: SumcheckPolyBase + ComponentPoly<K> + HasBackend + Send + Sync,
    P::Backend: SumcheckPolyBackend<P, K>,
{
    #[inline]
    fn fix_last_variable(self, alpha: K) -> Self {
        P::Backend::fix_last_variable(self, alpha)
    }

    #[inline]
    fn sum_as_poly_in_last_variable(&self, claim: Option<K>) -> UnivariatePolynomial<K> {
        P::Backend::sum_as_poly_in_last_variable(self, claim)
    }
}