Struct miden_vm::Proof

pub struct Proof {
    pub context: Context,
    pub num_unique_queries: u8,
    pub commitments: Commitments,
    pub trace_queries: Vec<Queries>,
    pub constraint_queries: Queries,
    pub ood_frame: OodFrame,
    pub fri_proof: FriProof,
    pub pow_nonce: u64,
    pub gkr_proof: Option<Vec<u8>>,
}

A proof generated by Winterfell prover.

A STARK proof contains information proving that a computation was executed correctly. A proof also contains basic metadata for the computation, but neither the definition of the computation itself, nor public inputs consumed by the computation are contained in a proof.

Optionally, it may contain a GKR proof. The GKR proof object gives the possibility to prove some auxiliary trace constraints using GKR, as described in Improving logarithmic derivative lookups using GKR.

A proof can be serialized into a sequence of bytes using to_bytes() function, and deserialized from a sequence of bytes using from_bytes() function.

To estimate soundness of a proof (in bits), security_level() function can be used.

Fields

context: Context

Basic metadata about the execution of the computation described by this proof.

num_unique_queries: u8

Number of unique queries made by the verifier. This will be different from the context.options.num_queries if the same position in the domain was queried more than once.

commitments: Commitments

Commitments made by the prover during the commit phase of the protocol.

trace_queries: Vec<Queries>

Decommitments of extended execution trace values (for all trace segments) at position queried by the verifier.

constraint_queries: Queries

Decommitments of constraint composition polynomial evaluations at positions queried by the verifier.

ood_frame: OodFrame

Trace and constraint polynomial evaluations at an out-of-domain point.

fri_proof: FriProof

Low-degree proof for a DEEP composition polynomial.

pow_nonce: u64

Proof-of-work nonce for query seed grinding.

gkr_proof: Option<Vec<u8>>

Optionally, an auxiliary (non-STARK) proof that was generated during auxiliary trace generation.

Implementations

impl Proof

pub fn options(&self) -> &ProofOptions

Returns STARK protocol parameters used to generate this proof.

pub fn trace_info(&self) -> &TraceInfo

Returns trace info for the computation described by this proof.

pub fn lde_domain_size(&self) -> usize

Returns the size of the LDE domain for the computation described by this proof.

pub fn security_level<H>(&self, conjectured: bool) -> u32

where H: Hasher,

Returns security level of this proof (in bits).

When conjectured is true, conjectured security level is returned; otherwise, provable security level is returned. Usually, the number of queries needed for provable security is 2x - 3x higher than the number of queries needed for conjectured security at the same security level.

pub fn to_bytes(&self) -> Vec<u8>

Serializes this proof into a vector of bytes.

pub fn from_bytes(source: &[u8]) -> Result<Proof, DeserializationError>

Returns a STARK proof read from the specified source.

Errors

Returns an error of a valid STARK proof could not be read from the specified source.

pub fn new_dummy() -> Proof

Creates a dummy Proof for use in tests.

Trait Implementations

impl Clone for Proof

fn clone(&self) -> Proof

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Proof

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

Formats the value using the given formatter.

impl Deserializable for Proof

fn read_from<R>(source: &mut R) -> Result<Proof, DeserializationError>

where R: ByteReader,

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

impl PartialEq for Proof

fn eq(&self, other: &Proof) -> 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 Serializable for Proof

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Eq for Proof

impl StructuralPartialEq for Proof