Struct BatchConstraintProof 

pub struct BatchConstraintProof<SC: StarkProtocolConfig> {
    pub numerator_term_per_air: Vec<SC::EF>,
    pub denominator_term_per_air: Vec<SC::EF>,
    pub univariate_round_coeffs: Vec<SC::EF>,
    pub sumcheck_round_polys: Vec<Vec<SC::EF>>,
    pub column_openings: Vec<Vec<Vec<SC::EF>>>,
}

Fields

numerator_term_per_air: Vec<SC::EF>

The terms \textnormal{sum}_{\hat{p}, T, I} as defined in Protocol 3.4.6, per present AIR in sorted AIR order.

denominator_term_per_air: Vec<SC::EF>

The terms \textnormal{sum}_{\hat{q}, T, I} as defined in Protocol 3.4.6, per present AIR in sorted AIR order.

univariate_round_coeffs: Vec<SC::EF>

Polynomial for initial round, given by (vk.d + 1) * (2^{l_skip} - 1) + 1 coefficients.

sumcheck_round_polys: Vec<Vec<SC::EF>>

For rounds 1, ..., n_max; evaluations on {1, ..., vk.d + 1}.

column_openings: Vec<Vec<Vec<SC::EF>>>

Per AIR in sorted AIR order, per AIR part, per column index in that part, openings for the prismalinear column polynomial and (optionally) its rotational convolution. All column openings are stored in a flat way, so only column openings or them interleaved with rotations. For example, if the rotated claims are included for a trace part, then the corresponding list of openings will look like [col_1, rot_1, col_2, rot_2, …], and should be treated as “the i-th column’s plain and rotated claims are (col_i, rot_i)”. Otherwise, it will look like [col_1, col_2, col_3, …], and should be treated as “the i-th column’s plain and rotated claims are (col_i, 0)”. The trace parts are ordered: [CommonMain (part 0), Preprocessed (if any), Cached(0), Cached(1), …]

Trait Implementations

impl<SC: StarkProtocolConfig> Clone for BatchConstraintProof<SC>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<SC: StarkProtocolConfig> Debug for BatchConstraintProof<SC>

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

Formats the value using the given formatter.

impl<SC: DecodableConfig> Decode for BatchConstraintProof<SC>

fn decode<R: Read>(reader: &mut R) -> Result<Self>

Reads and decodes a value from the given reader.

fn decode_from_bytes(bytes: &[u8]) -> Result<Self>

impl<'de, SC: StarkProtocolConfig> Deserialize<'de> for BatchConstraintProof<SC>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<SC: EncodableConfig> Encode for BatchConstraintProof<SC>

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

Writes the encoded representation of self to the given writer.

fn encode_to_vec(&self) -> Result<Vec<u8>>

Convenience method to encode into a Vec<u8>

impl<SC: StarkProtocolConfig> Eq for BatchConstraintProof<SC>

impl<SC: StarkProtocolConfig> PartialEq for BatchConstraintProof<SC>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<SC: StarkProtocolConfig> Serialize for BatchConstraintProof<SC>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.