Function batch_prove_unequal_depths 

pub fn batch_prove_unequal_depths<'a, A, F, P>(
    provers: Vec<FracAddCircuit<'a, A, P>>,
    claimed_fractions: Vec<Fraction<F>>,
    selector_point: Vec<F>,
    channel: &mut impl IPProverChannel<F>,
) -> BatchProveOutput<F>
where
    A: Allocator,
    F: Field,
    P: PackedField<Scalar = F>,

Runs a batched fractional-addition check for trees of unequal depths.

Every tree shallower than the deepest is proved over its zero-fraction-padded witness. super::padding states the identity that such a padding satisfies. The transcript is then exactly that of an equal-depth batch of the maximum depth. The verifier runs the ordinary binius_ip::fracaddcheck::verify over n_layers layers. It never learns the individual depths.

Every prover must reduce over all of its witness variables, so each fractional sum is a scalar and there is no content point. Dropping the content dimension keeps the padding bookkeeping to four scalars per layer.

The prover does not materialize the padded witnesses. Each layer’s per-tree reduction corrects the unpadded layer’s messages in $O(1)$ per round.

Arguments

• provers - The trees to batch, whose layer counts may differ.
• claimed_fractions - Each tree’s claimed root fraction, one per prover.
• selector_point - Evaluation point for the selector variables.
• channel - The channel for sending prover messages and sampling challenges.

Preconditions

• provers must be non-empty.
• Every prover’s witness must have exactly prover.n_layers() variables. A tree of depth zero is allowed — it is all padding, so its leaf claim is its root — but at least one tree must have a layer.
• 2^selector_point.len() >= provers.len().
• claimed_fractions.len() == provers.len().

Returns

A BatchProveOutput whose fractions are each tree’s leaf claim, in input order, at the shared reduced eval_point.

Those leaf claims are on the padded witnesses. super::unpad_leaf_claim reduces one to the claims on the tree’s own witness.