Struct snarkvm_algorithms::polycommit::sonic_pc::VerifierUnionKey

pub struct VerifierUnionKey<'a, E: PairingEngine> {
    pub vk: &'a VerifierKey<E>,
    pub degree_bounds_and_neg_powers_of_h: Option<Vec<(usize, &'a E::G2Affine)>>,
    pub degree_bounds_and_prepared_neg_powers_of_h: Option<Vec<(usize, &'a <E::G2Affine as PairingCurve>::Prepared)>>,
    pub supported_degree: usize,
    pub max_degree: usize,
}

VerifierKey is used to check evaluation proofs for a given commitment.

Fields

vk: &'a VerifierKey<E>

The verification key for the underlying KZG10 scheme.

degree_bounds_and_neg_powers_of_h: Option<Vec<(usize, &'a E::G2Affine)>>

Pairs a degree_bound with its corresponding G2 element. Each pair is in the form (degree_bound, \beta^{degree_bound - max_degree} h), where h is the generator of G2 above

degree_bounds_and_prepared_neg_powers_of_h: Option<Vec<(usize, &'a <E::G2Affine as PairingCurve>::Prepared)>>

The prepared version of degree_bounds_and_neg_powers_of_h.

supported_degree: usize

The maximum degree supported by the trimmed parameters that self is a part of.

max_degree: usize

The maximum degree supported by the UniversalParams self was derived from.

Implementations

impl<'a, E: PairingEngine> VerifierUnionKey<'a, E>

pub fn get_shift_power(&self, degree_bound: usize) -> Option<&E::G2Affine>

Find the appropriate shift for the degree bound.

pub fn get_prepared_shift_power( &self, degree_bound: usize ) -> Option<<E::G2Affine as PairingCurve>::Prepared>

pub fn max_degree(&self) -> usize

pub fn union<T: IntoIterator<Item = &'a VerifierKey<E>>>( verifier_keys: T ) -> Self

Trait Implementations

impl<'a, E: Clone + PairingEngine> Clone for VerifierUnionKey<'a, E>where E::G2Affine: Clone,

fn clone(&self) -> VerifierUnionKey<'a, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, E: Debug + PairingEngine> Debug for VerifierUnionKey<'a, E>where E::G2Affine: Debug,

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

Formats the value using the given formatter.

impl<'a, E: PartialEq + PairingEngine> PartialEq<VerifierUnionKey<'a, E>> for VerifierUnionKey<'a, E>where E::G2Affine: PartialEq,

fn eq(&self, other: &VerifierUnionKey<'a, E>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, E: Eq + PairingEngine> Eq for VerifierUnionKey<'a, E>where E::G2Affine: Eq,

impl<'a, E: PairingEngine> StructuralEq for VerifierUnionKey<'a, E>

impl<'a, E: PairingEngine> StructuralPartialEq for VerifierUnionKey<'a, E>