Struct MultipointEval 

pub struct MultipointEval<C>(/* private fields */);

Implementations

impl<C> MultipointEval<C>

where C: BaseFieldConfig + ProjectPrimitiveIntegersWithConfig + 'static, C::Integer: ConstTranscribable,

pub fn prove_as_subprotocol( transcript: &mut impl Transcript, families: Vec<MultipointEvalFamilyInputs<'_, C>>, shifts: &[ShiftSpec], q_star_cfg: &C, ) -> Result<Vec<(Proof<C::Element>, ProverState<C::Element>)>, MultipointEvalError<C::Element>>

Multi-point evaluation protocol prover (lockstep over families).

Drives one or more families of multi-point evaluation in lockstep, each family operating over its own field config. All families share the same UAIR-static [ShiftSpec]s, the same number of committed columns, the same number of bit-op virtual columns, and the same num_vars; they differ only in their per-family projected MLEs/scalars.

All protocol-level challenges $(\alpha_k, \gamma_j, \gamma^\mathrm{bit}_l)$ are sampled once as integers in $[0, q^*)$ via q_star_cfg and lifted into each family’s field via cfg.project. The inner sumcheck is driven by MultiDegreeSumcheck (one degree-2 group per family), so each round’s challenge is likewise shared across families and lifted per-family.

The single-family case (families.len() == 1) is the natural degenerate form; pass q_star_cfg = families[0].field_cfg.

Per family, proves

$$\sum_b \Bigl[, \mathrm{eq}(b, r^\star) ( \sum_j \gamma_j v_j(b) + \sum_l \gamma^\mathrm{bit}l w_l(b)) + \sum_k \alpha_k \cdot \mathrm{next}{c_k}(r^\star, b) \cdot v_{\mathrm{src}_k}(b) \Bigr] = \sum_j \gamma_j \cdot \mathrm{up\_eval}_j + \sum_l \gamma^\mathrm{bit}_l \cdot \mathrm{bit\_op\_eval}_l + \sum_k \alpha_k \cdot \mathrm{down\_eval}_k.$$

Returns one (Proof, ProverState) per family in family order. The caller is responsible for computing and sending lifted_evals at the shared $r_0$ for each family.

Panics

• If families is empty.
• If families disagree on num_vars or column counts.

pub fn verify_as_subprotocol( transcript: &mut impl Transcript, proofs: Vec<Proof<C::Element>>, families: Vec<MultipointEvalFamilyInputs<'_, C>>, shifts: &[ShiftSpec], num_vars: usize, q_star_cfg: &C, ) -> Result<Vec<Subclaim<C::Element>>, MultipointEvalError<C::Element>>

Multi-point evaluation protocol verifier (sumcheck phase, lockstep).

Mirror of [prove_as_subprotocol]: drives one or more families in lockstep, sharing batching coefficients and per-round challenges in $[0, q^*)$ via q_star_cfg. Returns one Subclaim per family carrying $r_0$, $\gamma_j$, $\alpha_k$, eq_at_r0, shifts_at_r0, and the inner sumcheck’s expected_evaluation. The caller finalizes via verify_subclaim once open_evals are available.

Panics

• If families is empty.
• If families disagree on num_vars or column counts.

pub fn verify_subclaim( subclaim: &Subclaim<C::Element>, open_evals: &[C::Element], bit_op_open_evals: &[C::Element], shifts: &[ShiftSpec], field_cfg: &C, ) -> Result<(), MultipointEvalError<C::Element>>

Finalize the multi-point evaluation check given open_evals for one family.

Verifies that eq_at_r0 * \sum_j(gamma_j * open_eval_j) + \sum_k(alpha_k * shift_at_r0_k * open_eval[source_col_k]) equals the sumcheck’s expected evaluation. This is a pure arithmetic check with no transcript interaction — call it once per family with that family’s open_evals.