Struct o1vm::legacy::trace::DecomposedTrace

pub struct DecomposedTrace<const N: usize, C: FoldingConfig> {
    pub domain_size: usize,
    pub trace: BTreeMap<C::Selector, Trace<N, C>>,
}

Struct representing a circuit execution trace which is decomposable in individual sub-circuits sharing the same columns. It is parameterized by

• N: the total number of columns (constant), it must equal N_REL + N_DSEL
• N_REL: the number of relation columns (constant),
• N_DSEL: the number of dynamic selector columns (constant),
• Selector: an enum representing the different gate behaviours,
• F: the type of the witness data.

Fields

domain_size: usize

The domain size of the circuit (should coincide with that of the traces)

trace: BTreeMap<C::Selector, Trace<N, C>>

The traces are indexed by the selector Inside the witness of the trace for a given selector,

• the last N_SEL columns represent the selector columns and only the one for Selector should be all ones (the rest of selector columns should be all zeros)

Implementations

impl<const N: usize, C: FoldingConfig> DecomposedTrace<N, C>where usize: From<<C as FoldingConfig>::Selector>,

pub fn number_of_rows(&self, opcode: C::Selector) -> usize

Returns the number of rows that have been instantiated for the given selector. It is important that the column used is a relation column because selector columns are only instantiated at the very end, so their length could be zero most times. That is the reason that relation columns are located first.

pub fn in_circuit(&self, opcode: C::Selector) -> bool

Returns a boolean indicating whether the witness for the given selector was ever found in the cirucit or not.

pub fn is_full(&self, opcode: C::Selector) -> bool

Returns whether the witness for the given selector has achieved a number of rows that is equal to the domain size.

pub fn reset(&mut self, opcode: C::Selector)

Resets the witness after folding

pub fn set_selector_column<const N_REL: usize>( &mut self, selector: C::Selector, number_of_rows: usize )

Sets the selector column to all ones, and the rest to all zeros

Trait Implementations

impl<const N: usize, C: Clone + FoldingConfig> Clone for DecomposedTrace<N, C>where C::Selector: Clone,

fn clone(&self) -> DecomposedTrace<N, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize, C: FoldingConfig<Column = Column, Curve = Curve>, Sponge> Foldable<N, C, Sponge> for DecomposedTrace<N, C>where C::Selector: Into<usize>, Sponge: FqSponge<<<C as FoldingConfig>::Curve as AffineRepr>::BaseField, C::Curve, <<C as FoldingConfig>::Curve as AffineRepr>::ScalarField>, <C as FoldingConfig>::Challenge: From<BerkeleyChallengeTerm>,

Implement the trait Foldable for the structure DecomposedTrace

fn to_folding_pair( &self, selector: C::Selector, fq_sponge: &mut Sponge, domain: D<<<C as FoldingConfig>::Curve as AffineRepr>::ScalarField>, srs: &PairingSRS<Pairing> ) -> (FoldingInstance<N, C::Curve>, FoldingWitness<N, <<C as FoldingConfig>::Curve as AffineRepr>::ScalarField>)

Returns the witness for the given selector as a folding witness and folding instance pair. Note that this function will also absorb all commitments to the columns to coin challenges appropriately.

fn folding_constraints( &self ) -> BTreeMap<C::Selector, Vec<FoldingCompatibleExpr<C>>>

Returns a map of constraints that are compatible with folding for each selector

impl<const N: usize, C: FoldingConfig> Index<<C as FoldingConfig>::Selector> for DecomposedTrace<N, C>

type Output = Trace<N, C>

The returned type after indexing.

fn index(&self, index: C::Selector) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize, const N_REL: usize, C: FoldingConfig, Env> Tracer<N_REL, C, Env> for DecomposedTrace<N, C>where DecomposedTrace<N, C>: DecomposableTracer<Env>, Trace<N, C>: Tracer<N_REL, C, Env, Selector = ()>, usize: From<<C as FoldingConfig>::Selector>,

Generic implementation of the Tracer trait for the DecomposedTrace struct. It requires the DecomposedTrace to implement the DecomposableTracer trait, and the Trace struct to implement the Tracer trait with Selector set to (), and usize to implement the From trait with C::Selector.

type Selector = <C as FoldingConfig>::Selector

fn init(domain_size: usize, _selector: C::Selector, env: &mut Env) -> Self

Initialize a new trace with the given domain size, selector, and environment.

fn push_row( &mut self, selector: Self::Selector, row: &[<<C as FoldingConfig>::Curve as AffineRepr>::ScalarField; N_REL] )

Add a witness row to the circuit (only for relation columns)

fn pad_with_row( &mut self, selector: Self::Selector, row: &[<<C as FoldingConfig>::Curve as AffineRepr>::ScalarField; N_REL] ) -> usize

Pad the rows of one opcode with the given row until reaching the domain size if needed. Returns the number of rows that were added. It does not add selector columns.

fn pad_with_zeros(&mut self, selector: Self::Selector) -> usize

Pads the rows of one opcode with zero rows until reaching the domain size if needed. Returns the number of rows that were added. It does not add selector columns.

fn pad_dummy(&mut self, selector: Self::Selector) -> usize

Pad the rows of one opcode with the first row until reaching the domain size if needed. It only tries to pad witnesses which are non empty. Returns the number of rows that were added. It does not add selector columns.