Struct FracAddCircuit 

pub struct FracAddCircuit<'a, A: Allocator, P: PackedField> { /* private fields */ }

The materialized layers of a fractional addition circuit.

Each layer holds the numerator and denominator of one fractional term per node. A layer is half the width of the one below it, each node adding its two children: $$\frac{a_0}{b_0} + \frac{a_1}{b_1} = \frac{a_0b_1 + a_1b_0}{b_0b_1}$$

Implementations

impl<'a, A, F, P> FracAddCircuit<'a, A, P>

where A: Allocator, F: Field, P: PackedField<Scalar = F>,

pub fn build( k: usize, alloc: &'a A, witness: Fraction<FieldVec<P, A>>, ) -> (Self, Fraction<FieldVec<P, A>>)

Materializes every layer of the circuit from witness.

Returns the circuit beside sums, its root layer. sums holds the fractional addition over all k reduced variables.

Arguments

• k - How many variables to reduce, one sibling fractional addition per step.
• witness - The witness numerator/denominator layers

Preconditions

• witness.num.log_len() >= k

pub const fn n_layers(&self) -> usize

Returns the number of remaining layers to prove.

pub fn pop_layer( &mut self, claim: FracAddEvalClaim<F>, ) -> LayerProver<'a, A, F, P>

Pops the widest remaining layer as the MLE-check prover that reduces it.

The returned prover owns the popped buffers and borrows only the allocator. So it outlives this borrow, and the circuit stays in place while a caller drives it.

Preconditions

• self.n_layers() >= 1

pub fn prove( self, claim: FracAddEvalClaim<F>, channel: &mut impl IPProverChannel<F>, ) -> FracAddEvalClaim<F>

Runs the fractional addition check protocol and returns the final evaluation claims.

This consumes the circuit, reducing from the smallest layer back to the largest.

Arguments

• claim - The numerator and denominator claims at their shared evaluation point.
• channel - The channel for sending prover messages and sampling challenges.

Preconditions

• claim.point.len() == witness.log_len() - k, for k the number of reduction layers.

Trait Implementations

impl<A: Allocator, P: PackedField> Clone for FracAddCircuit<'_, A, P>

where A::Vec<P>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.