Struct VerifierKey

pub struct VerifierKey<E: Pairing> { /* private fields */ }

The verification key for the polynomial commitment scheme. It also implements verification functions for the evaluation proof.

Implementations

impl<E: Pairing> VerifierKey<E>

pub fn verify( &self, commitment: &Commitment<E>, alpha: &E::ScalarField, evaluation: &E::ScalarField, proof: &EvaluationProof<E>, ) -> Result<(), VerificationError>

The verification procedure for the EvaluationProof with a single polynomial evaluated at a single evaluation point. The polynomial are evaluated at the point alpha and is committed as commitment. The evaluation proof can be obtained either in a space-efficient or a time-efficient flavour.

pub fn verify_multi_points( &self, commitments: &[Commitment<E>], eval_points: &[E::ScalarField], evaluations: &[Vec<E::ScalarField>], proof: &EvaluationProof<E>, open_chal: &E::ScalarField, ) -> Result<(), VerificationError>

The verification procedure for the EvaluationProof with a set of polynomials evaluated at a set of evaluation points. All the polynomials are evaluated at the set of points eval_points and are committed as commitments. evaluations contains evaluations of each polynomial at each point in eval_points. evaluations follows the same polynomial order as commitments and the same evaluation point order as eval_points. The evaluation proof can be obtained either in a space-efficient or a time-efficient flavour. open_chal is a random challenge for batching evaluation proofs across different polynomials.

Trait Implementations

impl<E: Debug + Pairing> Debug for VerifierKey<E>

where E::G1Affine: Debug, E::G2Affine: Debug,

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

Formats the value using the given formatter.

impl<E: Pairing> From<&CommitterKey<E>> for VerifierKey<E>

fn from(ck: &CommitterKey<E>) -> VerifierKey<E>

Converts to this type from the input type.

impl<E, SG> From<&CommitterKeyStream<E, SG>> for VerifierKey<E>

where E: Pairing, SG: Iterable, SG::Item: Borrow<E::G1Affine>,

fn from(ck: &CommitterKeyStream<E, SG>) -> Self

Converts to this type from the input type.

impl<E: PartialEq + Pairing> PartialEq for VerifierKey<E>

where E::G1Affine: PartialEq, E::G2Affine: PartialEq,

fn eq(&self, other: &VerifierKey<E>) -> 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<E: Eq + Pairing> Eq for VerifierKey<E>

where E::G1Affine: Eq, E::G2Affine: Eq,

impl<E: Pairing> StructuralPartialEq for VerifierKey<E>