Struct PolyComm 

pub struct PolyComm<C> {
    pub chunks: Vec<C>,
}

Represent a polynomial commitment when the type is instantiated with a curve.

The structure also handles chunking, i.e. when we aim to handle polynomials whose degree is higher than the SRS size. For this reason, we do use a vector for the field chunks.

Note that the parameter C is not constrained to be a curve, therefore in some places in the code, C can refer to a scalar field element. For instance, PolyComm<G::ScalarField> is used to represent the evaluation of the polynomial bound by a specific commitment, at a particular evaluation point.

Fields

chunks: Vec<C>

Implementations

impl<C> PolyComm<C>

where C: CommitmentCurve,

pub fn chunk_commitment(&self, zeta_n: C::ScalarField) -> Self

Multiplies each commitment chunk of f with powers of zeta^n

impl<F> PolyComm<F>

where F: Field,

pub fn chunk_blinding(&self, zeta_n: F) -> F

Multiplies each blinding chunk of f with powers of zeta^n

impl<T> PolyComm<T>

pub fn new(chunks: Vec<T>) -> Self

impl<A: Copy + Clone + CanonicalDeserialize + CanonicalSerialize> PolyComm<A>

pub fn map<B, F>(&self, f: F) -> PolyComm<B>

where F: FnMut(A) -> B, B: CanonicalDeserialize + CanonicalSerialize,

pub fn len(&self) -> usize

Returns the number of chunks.

pub fn is_empty(&self) -> bool

Returns true if the commitment is empty.

pub fn zip<B: Copy + CanonicalDeserialize + CanonicalSerialize>( &self, other: &PolyComm<B>, ) -> Option<PolyComm<(A, B)>>

pub fn get_first_chunk(&self) -> A

Return only the first chunk Getting this single value is relatively common in the codebase, even though we should not do this, and abstract the chunks in the structure.

impl<C: AffineRepr> PolyComm<C>

pub fn scale(&self, c: C::ScalarField) -> PolyComm<C>

pub fn multi_scalar_mul(com: &[&PolyComm<C>], elm: &[C::ScalarField]) -> Self

Performs a multi-scalar multiplication between scalars elm and commitments com. If both are empty, returns a commitment of length 1 containing the point at infinity.

Panics

Panics if com and elm are not of the same size.

Trait Implementations

impl<'a, C: AffineRepr> Add<&'a PolyComm<C>> for &PolyComm<C>

type Output = PolyComm<C>

The resulting type after applying the + operator.

fn add(self, other: &'a PolyComm<C>) -> PolyComm<C>

Performs the + operation.

impl<C: Clone> Clone for PolyComm<C>

fn clone(&self) -> PolyComm<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for PolyComm<C>

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

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for PolyComm<C>

where C: CanonicalDeserialize + CanonicalSerialize,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T, U> DeserializeAs<'de, PolyComm<T>> for PolyComm<U>

where U: DeserializeAs<'de, T>,

fn deserialize_as<D>(deserializer: D) -> Result<PolyComm<T>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, G, CamlG> From<&'a CamlPolyComm<CamlG>> for PolyComm<G>

where G: AffineRepr + From<&'a CamlG> + From<CamlG>,

fn from(camlpolycomm: &'a CamlPolyComm<CamlG>) -> PolyComm<G>

Converts to this type from the input type.

impl<'a, G, CamlG> From<&'a PolyComm<G>> for CamlPolyComm<CamlG>

where G: AffineRepr, CamlG: From<G> + From<&'a G>,

fn from(polycomm: &'a PolyComm<G>) -> Self

Converts to this type from the input type.

impl<G, CamlG> From<CamlPolyComm<CamlG>> for PolyComm<G>

where G: AffineRepr + From<CamlG>,

fn from(camlpolycomm: CamlPolyComm<CamlG>) -> PolyComm<G>

Converts to this type from the input type.

impl<G, CamlG> From<PolyComm<G>> for CamlPolyComm<CamlG>

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

fn from(polycomm: PolyComm<G>) -> Self

Converts to this type from the input type.

impl<'a, G> IntoIterator for &'a PolyComm<G>

type Item = &'a G

The type of the elements being iterated over.

type IntoIter = Iter<'a, G>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<C: PartialEq> PartialEq for PolyComm<C>

fn eq(&self, other: &PolyComm<C>) -> 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<C> Serialize for PolyComm<C>

where C: 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<T, U> SerializeAs<PolyComm<T>> for PolyComm<U>

where U: SerializeAs<T>,

fn serialize_as<S>( source: &PolyComm<T>, serializer: S, ) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, C: AffineRepr + Sub<Output = C::Group>> Sub<&'a PolyComm<C>> for &PolyComm<C>

type Output = PolyComm<C>

The resulting type after applying the - operator.

fn sub(self, other: &'a PolyComm<C>) -> PolyComm<C>

Performs the - operation.

impl<C: Eq> Eq for PolyComm<C>

impl<C> StructuralPartialEq for PolyComm<C>