Struct ExpressionClaimCols 

#[repr(C)]
pub struct ExpressionClaimCols<T> {

    pub is_valid: T,
    pub is_first: T,
    pub proof_idx: T,
    pub group_idx: T,
    pub is_first_in_group: T,
    pub idx: T,
    pub idx_parity: T,
    pub trace_idx: T,
    pub value: [T; 4],
    pub eq_sharp_ns: [T; 4],
    pub cur_sum: [T; 4],
    pub mu: [T; 4],
    pub multiplier: [T; 4],
    pub n_abs: T,
    pub n_abs_pow: T,
    pub n_sign: T,
    pub num_multilinear_sumcheck_rounds: T,
}

For each proof, this AIR will receive 2t interaction claims and t constraint claims. (2 interaction claims and 1 constraint claim per trace). These values are folded (algebraic batching) with mu into a single value, which should match the final sumcheck claim.

Rows are structured as a nested loop: for each proof, group 0 (interactions) comes first, then group 1 (constraints). Within the interaction group, each trace occupies 2 rows (numerator then denominator). Within the constraint group, each trace occupies 1 row. NestedForLoopSubAir<4> enforces canonical nested enumeration over (proof_idx, group_idx, trace_idx, idx_parity).

Example for t = 2 traces (one proof):

row | is_first | group_idx | is_first_in_group | trace_idx | idx_parity | idx
----|----------|-----------|-------------------|-----------|------------|----
  0 |    1     |     0     |         1         |     0     |     0      |  0   ← numerator trace 0
  1 |    0     |     0     |         0         |     0     |     1      |  1   ← denominator trace 0
  2 |    0     |     0     |         0         |     1     |     0      |  2   ← numerator trace 1
  3 |    0     |     0     |         0         |     1     |     1      |  3   ← denominator trace 1
  4 |    0     |     1     |         1         |     0     |     0      |  0   ← constraint trace 0
  5 |    0     |     1     |         0         |     1     |     0      |  1   ← constraint trace 1

is_interaction is derived as 1 - group_idx (not a separate column).

Fields

is_valid: T

is_first: T

First row of a proof. Marks proof boundaries.

proof_idx: T

group_idx: T

0 = interaction group, 1 = constraint group. Monotone within a proof.

is_first_in_group: T

Marks the first row of each group (set at proof start and interaction→constraint boundary).

idx: T

Claim index within its group. For interactions: 2 * trace_idx + idx_parity (0..2t). For constraints: trace_idx (0..t).

idx_parity: T

0 = numerator, 1 = denominator. Always 0 on constraint rows. Alternates on interaction rows.

trace_idx: T

Sorted trace index within the group. Monotone non-decreasing; resets at group boundaries.

value: [T; 4]

The received evaluation claim. Note that for interactions, this is without norm_factor and eq_sharp_ns. These are interactions_evals (without norm_factor and eq_sharp_ns) and constraint_evals in the rust verifier.

eq_sharp_ns: [T; 4]

Receive from eq_ns AIR

cur_sum: [T; 4]

For folding with mu.

mu: [T; 4]

multiplier: [T; 4]

n_abs: T

Need to know n as if n<0, we need to multiply some norm_factor.

n_abs_pow: T

n_sign: T

num_multilinear_sumcheck_rounds: T

The round idx for final sumcheck claim.

Implementations

impl<T> ExpressionClaimCols<T>

pub const fn width() -> usize

pub fn as_slice(&self) -> &[T]

pub fn as_slice_mut(&mut self) -> &mut [T]

Mutable view of the whole struct as a contiguous slice of T.

pub fn to_vec(&self) -> Vec<T>

where T: Clone,

Copy out the contents as a Vec. Requires T: Clone for the slice .to_vec().

Trait Implementations

impl<T> Borrow<ExpressionClaimCols<T>> for [T]

fn borrow(&self) -> &ExpressionClaimCols<T>

Immutably borrows from an owned value.

impl<T> BorrowMut<ExpressionClaimCols<T>> for [T]

fn borrow_mut(&mut self) -> &mut ExpressionClaimCols<T>

Mutably borrows from an owned value.

impl<T: Clone> Clone for ExpressionClaimCols<T>

fn clone(&self) -> ExpressionClaimCols<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ExpressionClaimCols<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> StructReflectionHelper for ExpressionClaimCols<T>

fn struct_reflection() -> Option<Vec<String>>

impl<T: Copy> Copy for ExpressionClaimCols<T>