Struct DoryProof 

pub struct DoryProof<G1: Group, G2, GT> {
    pub vmv_message: VMVMessage<G1, GT>,
    pub first_messages: Vec<FirstReduceMessage<G1, G2, GT>>,
    pub second_messages: Vec<SecondReduceMessage<G1, G2, GT>>,
    pub final_message: ScalarProductMessage<G1, G2>,
    pub nu: usize,
    pub sigma: usize,
    pub e2: Option<G2>,
    pub y_com: Option<G1>,
    pub sigma1_proof: Option<Sigma1Proof<G1, G2, G1::Scalar>>,
    pub sigma2_proof: Option<Sigma2Proof<G1::Scalar, GT>>,
    pub scalar_product_proof: Option<ScalarProductProof<G1, G2, G1::Scalar, GT>>,
}

A complete Dory evaluation proof

The proof demonstrates that a committed polynomial evaluates to a specific value at a given point. It consists of messages from the interactive protocol made non-interactive via Fiat-Shamir.

The proof includes the matrix dimensions (nu, sigma) used during proof generation, which the verifier uses to ensure consistency with the evaluation point.

Fields

vmv_message: VMVMessage<G1, GT>

Vector-Matrix-Vector message for PCS transformation

first_messages: Vec<FirstReduceMessage<G1, G2, GT>>

First reduce messages for each round (nu rounds total)

second_messages: Vec<SecondReduceMessage<G1, G2, GT>>

Second reduce messages for each round (nu rounds total)

final_message: ScalarProductMessage<G1, G2>

Final scalar product message

nu: usize

Log₂ of number of rows in the coefficient matrix

sigma: usize

Log₂ of number of columns in the coefficient matrix

e2: Option<G2>

Blinded E₂ element for zero-knowledge proofs

y_com: Option<G1>

Pedersen commitment to the blinding vector y

sigma1_proof: Option<Sigma1Proof<G1, G2, G1::Scalar>>

Σ₁ proof: E₂ and y_com commit to the same y

sigma2_proof: Option<Sigma2Proof<G1::Scalar, GT>>

Σ₂ proof: consistency of E₁ with D₂

scalar_product_proof: Option<ScalarProductProof<G1, G2, G1::Scalar, GT>>

ZK scalar product proof: (C, D₁, D₂) consistency with blinded vectors

Trait Implementations

impl<G1: Clone + Group, G2: Clone, GT: Clone> Clone for DoryProof<G1, G2, GT>

where G1::Scalar: Clone,

fn clone(&self) -> DoryProof<G1, G2, GT>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G1: Debug + Group, G2: Debug, GT: Debug> Debug for DoryProof<G1, G2, GT>

where G1::Scalar: Debug,

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

Formats the value using the given formatter.

impl<G1: PartialEq + Group, G2: PartialEq, GT: PartialEq> PartialEq for DoryProof<G1, G2, GT>

where G1::Scalar: PartialEq,

fn eq(&self, other: &DoryProof<G1, G2, GT>) -> 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<G1: Group, G2, GT> StructuralPartialEq for DoryProof<G1, G2, GT>