Struct IdealCollector 

pub struct IdealCollector<I: Ideal, IFq: Ideal> {
    pub ideals: Vec<IdealOrZero<I>>,
    pub fq_ideals: Vec<Vec<IdealOrZero<IFq>>>,
}

A ConstraintBuilder that collects ideals used in a Uair.

Both $Q[X]$-only-ideals (from ConstraintBuilder::assert_in_ideal / ConstraintBuilder::assert_zero) and new $F_{q_i}[X]$-ideals (from ConstraintBuilder::assert_in_fq_ideal) are kept in separate vectors, so downstream consumers (the PIOP layer) can dispatch them independently. The $F_q[X]$ ideals are wrapped in IdealOrZero to reuse the unconditional IdealCheck (over DummySemiring) proxy impl used during the collection; the Zero variant is never produced by the collection (there is no assert_fq_zero) but downstream consumers may construct it.

Fields

ideals: Vec<IdealOrZero<I>>

fq_ideals: Vec<Vec<IdealOrZero<IFq>>>

$F_{q_i}[X]$-ideals indexed by their prime_idx into the owning UAIR’s crate::UairSignature::primes tuple. Empty for UAIRs with $Q[X]$-only constraints.

Implementations

impl<I: Ideal, IFq: Ideal> IdealCollector<I, IFq>

pub fn new(num_constraints: usize) -> Self

Create a new ideal collector and hint the number of constraints a target UAIR might have.

Trait Implementations

impl<I, IFq> ConstraintBuilder for IdealCollector<I, IFq>

where I: Ideal, IFq: Ideal,

type Expr = DummySemiring

The expressions the constraint builder operates on. It is opaque from the PoV of an AIR: arithmetic operations on it are provided by the expression config passed to Uair::constrain_general alongside the builder.

type Ideal = IdealOrZero<I>

The type of ideals used by the constraint builder.

type FqIdeal = IdealOrZero<IFq>

Ideals living over $F_{q_i}[X]$ for the prime tuple declared by the surrounding UairSignature::primes. A single ConstraintBuilder shares one runtime type for all primes; the prime index is passed at the call site via ConstraintBuilder::assert_in_fq_ideal. Builders that don’t care about $F_q[X]$-constraints (counters, collectors, etc.) set this to ImpossibleIdeal.

fn assert_in_ideal(&mut self, _expr: Self::Expr, ideal: &Self::Ideal)

Add a constraint saying that expr belongs to the ideal ideal.

fn assert_zero(&mut self, _expr: Self::Expr)

Add a constraint saying that expr is equal to zero which is the same as saying that expr belongs to the zero ideal.

fn assert_in_fq_ideal( &mut self, prime_idx: usize, _expr: Self::Expr, ideal: &Self::FqIdeal, )

Add a constraint saying that expr, after coefficient-wise reduction mod $q_{\text{prime_index}}$ (the paper’s $\phi_{q_i}$), belongs to the $F_{q_i}[X]$-ideal ideal.