Struct ZeroPadMleCheckProver 

pub struct ZeroPadMleCheckProver<F: Field, Inner> { /* private fields */ }

MLE-check prover for one layer of a fractional-addition check over a zero-fraction-padded witness.

The tree’s fractional sum is a scalar, so the layer’s claim point is node coordinates only, split into two segments with the padding ones lowest:

    [ padding (nu) | real (m) ]

The padded layer is the unpadded one with its numerators scaled by $\textsf{eq}(0^\nu, Z’)$ and its denominators wrapped in the one-padding $\textsf{sel}(\textsf{eq}(0^\nu, Z’), \cdot)$ over the padding variables. MLE-check binds variables from the highest index down, so the real rounds come first and the padding rounds last:

• Real rounds. Delegate to inner, the ordinary MLE-check over the unpadded layer, and correct its two round polynomials, where $q$ is the equality weight $\textsf{eq}(0^\nu, \rho_\text{pa})$ of the claim point’s padding segment. Off the all-zeros padding slab every leaf is the zero fraction, whose numerator composition vanishes and whose denominator composition is one, so the numerator’s polynomial is scaled to $q \cdot R(X)$ and the denominator’s shifted to $1 + q \cdot (R(X) - 1)$.
• Padding rounds. No multilinear is touched. Every real variable is bound by now, so inner’s four child evaluations are scalars and both round polynomials are closed forms in them, quadratic through $E(X)$, the equality weight of the padding coordinates already bound together with this round’s.

MleCheckProver::finish returns the padded layer’s child evaluations, which is what the batch’s selector rounds consume.

Trait Implementations

impl<F: Field, Inner: MleCheckProver<F>> MleCheckProver<F> for ZeroPadMleCheckProver<F, Inner>

fn n_vars(&self) -> usize

The number of variables still free.

fn execute(&mut self) -> Vec<RoundCoeffs<F>>

Computes this round’s message, one univariate polynomial per claim.

fn fold(&mut self, challenge: F)

Binds this round’s variable to the verifier challenge.

fn finish(self) -> Vec<F>

Consumes the prover and returns every multilinear’s evaluation at the challenge point.

fn eval_point(&self) -> &[F]

The still-unbound part of the evaluation point, one coordinate per free variable.