Struct ClaimGroup 

pub struct ClaimGroup<F: Field> {
    pub claims: Vec<RawClaim<F>>,
    claim_points_matrix: Vec<Vec<F>>,
    claim_points_transpose: Vec<Vec<F>>,
    result_vector: Vec<F>,
}

Stores a collection of claims and provides an API running claim aggregation algorithms on them. The current implementation introduces up to 3x memory redundancy in order to achieve faster access times. Invariant: All claims are on the same number of variables.

Fields

claims: Vec<RawClaim<F>>

A vector of raw claims in F^n.

claim_points_matrix: Vec<Vec<F>>

A 2D matrix with the claim’s points as its rows.

claim_points_transpose: Vec<Vec<F>>

The points in claims is effectively a matrix of elements in F. We also store the transpose of this matrix for convenient access.

result_vector: Vec<F>

A vector of self.get_num_claims() elements. For each claim i, result_vector[i] stores the expected result of the i-th claim.

Implementations

impl<F: Field> ClaimGroup<F>

pub fn new(claims: Vec<Claim<F>>) -> Result<Self>

Generates a ClaimGroup from a collection of Claims. All claims agree on the Claim::to_layer_id field and returns ClaimError::LayerIdMismatch otherwise. Returns ClaimError::NumVarsMismatch if the collection of claims do not all agree on the number of variables.

pub fn new_from_raw_claims(claims: Vec<RawClaim<F>>) -> Result<Self>

Generates a new ClaimGroup from a collection of RawClaims. Returns ClaimError::NumVarsMismatch if the collection of claims do not all agree on the number of variables.

pub fn get_num_claims(&self) -> usize

Returns the number of claims stored in this group.

pub fn is_empty(&self) -> bool

Returns true if the group contains no claims.

pub fn get_num_vars(&self) -> usize

Returns the number of indices of the claims stored. Panics if no claims present.

pub fn get_points_column(&self, i: usize) -> &Vec<F>

Returns a reference to a vector of self.get_num_claims() elements, the j-th entry of which is the i-th coordinate of the j-th claim’s point. In other words, it returns the i-th column of the matrix containing the claim points as its rows.

Panics

When i is not in the range: 0 <= i < self.get_num_vars().

pub fn get_claim_points_matrix(&self) -> &Vec<Vec<F>>

Returns a reference to an “m x n” matrix where n = self.get_num_vars() and m = self.get_num_claims() with the claim points as its rows.

pub fn get_results(&self) -> &Vec<F>

Returns a reference to a vector with m = self.get_num_claims() elements containing the results of all claims.

pub fn get_raw_claim(&self, i: usize) -> &RawClaim<F>

Returns a reference to the i-th claim.

pub fn get_raw_claims(&self) -> &[RawClaim<F>]

Returns a reference to a vector of claims contained in this group.

fn preprocess_claims(claims: Vec<Claim<F>>) -> Vec<Claim<F>>

Returns claims sorted by from_layer_id to prepare them for grouping. Also performs claim de-duplication by eliminating copies of claims on the same point.

pub fn form_claim_groups(claims: Vec<Claim<F>>) -> Vec<Self>

Partition claims into groups to be aggregated together.

fn compute_aggregated_challenges(&self, r_star: F) -> Result<Vec<F>>

Computes the aggregated challenge point by interpolating a polynomial passing through all the points in the claim group and then evaluating it at r_star. More precicely, if self.claims contains m points [u_0, u_1, ..., u_{m-1}] where each u_i \in F^n, it computes a univariate polynomial vector l : F -> F^n such that l(0) = u_0, l(1) = u_1, ..., l(m-1) = u_{m-1} using Lagrange interpolation, then evaluates l on r_star and returns it.

Requires

self.claims_points should be non-empty, otherwise a ClaimError::ClaimAggroError is returned. Using the ClaimGroup abstraction here is not ideal since we are only operating on the points and not on the results. However, the ClaimGroup API is convenient for accessing columns and makes the implementation more readable. We should consider alternative designs.

pub fn prover_aggregate( &self, layer_mles: &[DenseMle<F>], transcript_writer: &mut impl ProverTranscript<F>, ) -> Result<RawClaim<F>>

Performs claim aggregation on the prover side for this claim group in a single stage – this is the standard “Thaler13” claim aggregation without any heuristic optimizations.

Parameters

• layer_mles: the compiled bookkeeping tables from this layer, which when aggregated appropriately with their prefix bits, make up the layerwise bookkeeping table.
• layer: the layer whose output MLE is being made a claim on. Each of the claims are aggregated into one claim, whose validity is reduced to the validity of a claim in a future layer throught he sumcheck protocol.
• transcript_writer: is used to post wlx evaluations and generate challenges.

Returns

If successful, returns a single aggregated claim.

pub fn verifier_aggregate( &self, transcript_reader: &mut impl VerifierTranscript<F>, ) -> Result<RawClaim<F>>

Performs claim aggregation on the verifier side for this claim group in a single stage – this is the standard “Thaler13” claim aggregation without any heuristic optimizations.

Parameters

• transcript_reader: is used to retrieve wlx evaluations and generate challenges.

Returns

If successful, returns a single aggregated claim.

Trait Implementations

impl<F: Clone + Field> Clone for ClaimGroup<F>

fn clone(&self) -> ClaimGroup<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Field> Debug for ClaimGroup<F>

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

Formats the value using the given formatter.