Struct RecursionChallenge 

pub struct RecursionChallenge<G>
where
    G: AffineRepr,
{
    pub chals: Vec<G::ScalarField>,
    pub comm: PolyComm<G>,
}

A struct to store the challenges inside a ProverProof

Fields

chals: Vec<G::ScalarField>

Vector of scalar field elements

comm: PolyComm<G>

Polynomial commitment

Implementations

impl<G: AffineRepr> RecursionChallenge<G>

pub fn new( chals: Vec<G::ScalarField>, comm: PolyComm<G>, ) -> RecursionChallenge<G>

pub fn evals( &self, max_poly_size: usize, evaluation_points: &[G::ScalarField], powers_of_eval_points_for_chunks: &[G::ScalarField], ) -> Vec<Vec<G::ScalarField>>

Trait Implementations

impl<G> Clone for RecursionChallenge<G>

where G: AffineRepr + Clone, G::ScalarField: Clone,

fn clone(&self) -> RecursionChallenge<G>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<G> Debug for RecursionChallenge<G>

where G: AffineRepr + Debug, G::ScalarField: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, G> Deserialize<'de> for RecursionChallenge<G>

where G: AffineRepr + CanonicalDeserialize + CanonicalSerialize,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G, CamlG, CamlF> From<CamlRecursionChallenge<CamlG, CamlF>> for RecursionChallenge<G>

where G: AffineRepr + From<CamlG>, G::ScalarField: From<CamlF>,

fn from(caml_ch: CamlRecursionChallenge<CamlG, CamlF>) -> RecursionChallenge<G>

Converts to this type from the input type.

impl<G, CamlG, CamlF> From<RecursionChallenge<G>> for CamlRecursionChallenge<CamlG, CamlF>

where G: AffineRepr, CamlG: From<G>, CamlF: From<G::ScalarField>,

fn from(ch: RecursionChallenge<G>) -> Self

Converts to this type from the input type.

impl<G> PartialEq for RecursionChallenge<G>

where G: AffineRepr + PartialEq, G::ScalarField: PartialEq,

fn eq(&self, other: &RecursionChallenge<G>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<G> Serialize for RecursionChallenge<G>

where G: AffineRepr + CanonicalDeserialize + CanonicalSerialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<G> StructuralPartialEq for RecursionChallenge<G>

where G: AffineRepr,