Struct Proof 

pub struct Proof<G: AffineRepr> {
    pub l_vec: Vec<G>,
    pub r_vec: Vec<G>,
    pub final_comm_key: G,
    pub c: G::ScalarField,
    pub hiding_comm: Option<G>,
    pub rand: Option<G::ScalarField>,
}

Proof is an evaluation proof that is output by InnerProductArg::open.

Fields

l_vec: Vec<G>

Vector of left elements for each of the log_d iterations in open

r_vec: Vec<G>

Vector of right elements for each of the log_d iterations within open

final_comm_key: G

Committer key from the last iteration within open

c: G::ScalarField

Coefficient from the last iteration within withinopen`

hiding_comm: Option<G>

Commitment to the blinding polynomial.

rand: Option<G::ScalarField>

Linear combination of all the randomness used for commitments to the opened polynomials, along with the randomness used for the commitment to the hiding polynomial.

Trait Implementations

impl<G: AffineRepr> CanonicalDeserialize for Proof<G>

fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

Reads Self from reader using the compressed form if applicable. Performs validation if applicable.

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

Reads Self from reader using the compressed form if applicable, without validating the deserialized value.

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

Reads Self from reader using the uncompressed form. Performs validation if applicable.

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

Reads Self from reader using the uncompressed form, without validating the deserialized value.

impl<G: AffineRepr> CanonicalSerialize for Proof<G>

fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

Returns the size in bytes of the serialized version of self with the given compression mode.

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

Serializes self into writer using the compressed form if applicable.

fn compressed_size(&self) -> usize

Returns the size in bytes of the compressed serialized version of self.

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

Serializes self into writer using the uncompressed form.

fn uncompressed_size(&self) -> usize

Returns the size in bytes of the uncompressed serialized version of self.

impl<G: AffineRepr> Clone for Proof<G>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G: AffineRepr> Debug for Proof<G>

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

Formats the value using the given formatter.

impl<G: AffineRepr> Default for Proof<G>

fn default() -> Self

Returns the “default value” for a type.

impl<G: AffineRepr> Hash for Proof<G>

fn hash<__HG>(&self, __state: &mut __HG)

where __HG: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<G: AffineRepr> Valid for Proof<G>

const TRIVIAL_CHECK: bool

Whether the check method is trivial (i.e. always returns Ok(())). If this is true, the batch_check method will skip all checks and return Ok(()). This should be set to true for types where check is trivial, e.g. integers, field elements, etc. This is false by default. This is primarily an optimization to skip unnecessary checks in batch_check.

fn check(&self) -> Result<(), SerializationError>

Checks whether self is valid. If self is valid, returns Ok(()). Otherwise, returns an error describing the failure. This method is called by deserialize_with_mode if validate is Validate::Yes.

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,

Checks whether all items in batch are valid. If all items are valid, returns Ok(()). Otherwise, returns an error describing the first failure.