Struct ark_poly_commit::ipa_pc::Proof

pub struct Proof<G: AffineCurve> {
    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: AffineCurve> CanonicalDeserialize for Proof<G>

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

Reads Self from reader.

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

Reads Self from reader without compression.

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

Reads self from reader without compression, and without performing validity checks. Should be used only when the input is trusted.

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

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

Serializes self into writer. It is left up to a particular type for how it strikes the serialization efficiency vs compression tradeoff. For standard types (e.g. bool, lengths, etc.) typically an uncompressed form is used, whereas for algebraic types compressed forms are used.

fn serialized_size(&self) -> usize

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

Serializes self into writer without compression.

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

Serializes self into writer without compression, and without performing validity checks. Should be used only when there is no danger of adversarial manipulation of the output.

fn uncompressed_size(&self) -> usize

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<G: AffineCurve> 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, 

Feeds a slice of this type into the given Hasher.

impl<G: AffineCurve> PCProof for Proof<G>

fn size_in_bytes(&self) -> usize

Size in bytes

impl<G: AffineCurve> ToBytes for Proof<G>

fn write<W: Write>(&self, writer: W) -> Result<()>

Serializes self into writer.