Struct FRIParams 

pub struct FRIParams<F> { /* private fields */ }

Parameters for an FRI interleaved code proximity protocol.

Invariants

The dimension of the first-round (reduced) FRI oracle is rs_code.log_dim() == log_terminal_dim + sum(fold_arities). For all oracle specs in input_oracles:

• log_batch_size <= log_msg_len
• log_msg_len <= rs_code.log_dim() + log_batch_size (equivalently, log_msg_len <= log_terminal_dim + sum(fold_arities) + log_batch_size)

Implementations

impl<F> FRIParams<F>

pub fn rs_code(&self) -> &ReedSolomonCode<F>

The Reed-Solomon code the verifier is testing proximity to.

impl<F> FRIParams<F>

pub fn n_test_queries(&self) -> usize

The number oracle consistency queries required during the query phase.

impl<F> FRIParams<F>

where F: BinaryField,

pub fn new( rs_code: ReedSolomonCode<F>, log_batch_size: usize, fold_arities: Vec<usize>, n_test_queries: usize, ) -> Self

Preconditions

• sum(fold_arities) must be at most rs_code.log_dim().

pub fn new_batch( rs_code: ReedSolomonCode<F>, oracles: Vec<CodewordSpec>, fold_arities: Vec<usize>, n_test_queries: usize, ) -> Self

Create parameters for a batch of committed codewords with an explicit per-codeword layout.

This is the low-level constructor: the caller supplies the reduced Reed–Solomon code, each codeword’s lift / early & later batch-fold routing, and the fold arities. The proof-size-minimizing selection of those values from a batch of higher-level oracle descriptions lives in Self::optimal_for_batch.

Preconditions

• oracles is non-empty.
• sum(fold_arities) must be at most rs_code.log_dim().
• For each oracle, log_lift <= rs_code.log_dim().

pub fn with_strategy<MerkleScheme, Strategy>( merkle_scheme: &MerkleScheme, log_msg_len: usize, log_batch_size: Option<usize>, log_inv_rate: usize, n_test_queries: usize, strategy: &Strategy, ) -> Self

where MerkleScheme: MerkleTreeScheme<F>, Strategy: AritySelectionStrategy,

Create parameters using the given arity selection strategy.

Arguments

• merkle_scheme - the Merkle tree scheme used for commitments.
• log_msg_len - the binary logarithm of the length of the message to commit.
• log_batch_size - if Some, fixes the batch size; if None, the batch size is chosen optimally along with the fold arities.
• log_inv_rate - the binary logarithm of the inverse Reed–Solomon code rate.
• n_test_queries - the number of test queries for the FRI protocol.
• strategy - the strategy for selecting fold arities.

Preconditions

• If log_batch_size is Some(b), then b <= log_msg_len.

pub fn optimal_for_batch<MerkleScheme>( merkle_scheme: &MerkleScheme, oracles: &[OracleSpec], log_inv_rate: usize, n_test_queries: usize, ) -> (Self, usize)

where MerkleScheme: MerkleTreeScheme<F>,

Create parameters for a batch of input oracles, minimizing the estimated proof size.

The input oracles may have differing message lengths. Each oracle is reduced into a common first-round FRI oracle, whose dimension is chosen to minimize the estimated proof size; the per-oracle batch sizes and the subsequent fold arities are chosen along with it.

Returns the parameters together with the estimated proof size in bytes.

Arguments

• merkle_scheme - the Merkle tree scheme used for commitments.
• oracles - the oracles to batch. A ZK oracle commits its message interleaved with an equal-length mask (fixed log_batch_size = 1); a non-ZK oracle commits the bare message with a batch size chosen optimally.
• log_inv_rate - the binary logarithm of the inverse Reed–Solomon code rate.
• n_test_queries - the number of test queries for the FRI protocol.

Preconditions

• oracles is non-empty.

pub const fn n_fold_rounds(&self) -> usize

Number of folding rounds in the FRI protocol.

This is the largest input message length, plus log_n_oracles extra rounds that fold the distinct input oracles together into the batched codeword.

pub const fn n_oracles(&self) -> usize

Number of oracles sent during the fold rounds.

pub const fn index_bits(&self) -> usize

Number of bits in the query indices sampled during the query phase.

pub const fn n_final_challenges(&self) -> usize

Number of folding challenges the verifier sends after receiving the last oracle.

pub fn fold_arities(&self) -> &[usize]

The reduction arities between each oracle sent to the verifier.

pub fn input_oracles(&self) -> &[CodewordSpec]

The specifications of the input oracles batched into the first-round FRI oracle.

pub fn log_batch_size(&self) -> usize

The arity of the reduction to the first round oracle.

pub fn log_len(&self) -> usize

The binary logarithm of the length of the initial oracle.

pub const fn log_msg_len(&self) -> usize

The binary logarithm of the length of the initial message.

This includes the log_n_oracles extra rounds used to fold the distinct input oracles together, so it equals Self::n_fold_rounds.

Trait Implementations

impl<F: Clone> Clone for FRIParams<F>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for FRIParams<F>

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

Formats the value using the given formatter.