Struct SlotLayout 

pub struct SlotLayout {
    pub plan: RingSwitchPlan,
    pub num_vars: usize,
    pub split_vars: usize,
    pub slot_rs: Vec<ColumnType>,
    pub h_slots: usize,
    pub num_sigma: usize,
    /* private fields */
}

A RingSwitchPlan at one table height: committed columns in codeword slots, block b of a slot at message offset b · 2^num_vars, and one eta exponent per slot role.

Fields

plan: RingSwitchPlan

num_vars: usize

split_vars: usize

slot_rs: Vec<ColumnType>

h_slots: usize

num_sigma: usize

Implementations

impl SlotLayout

pub fn pack_vars(&self) -> usize

pub fn pack(&self) -> usize

pub fn grid_cols(&self) -> usize

pub fn grid_rows(&self) -> usize

pub fn slot_columns(&self, slot: usize) -> &[usize]

Plan columns of trace slot slot, in block order.

pub fn h_slot_columns(&self, slot: usize) -> Range<usize>

pub fn leaf_row_bytes(&self) -> usize

pub fn h_leaf_row_bytes(&self) -> usize

pub fn unit_block(&self, unit: usize) -> usize

pub fn blind_salt(&self, blind: usize) -> usize

PRF salt of blind column blind’s message, past every slot’s support salt.

pub fn unit_weights<F: HardwareField>( &self, eta: Flat<F>, rho: &[Flat<F>], ) -> Result<(Vec<Flat<F>>, Flat<F>), Error>

Per-unit claim weights eta^σ(u) · eq(rho, b(u)) and the next-row factor eta^#σ. Errors unless rho holds one challenge per pack variable.

pub fn sigma_weights<F: HardwareField>( &self, eta: Flat<F>, ) -> (Vec<Flat<F>>, Flat<F>)

pub fn slot_coeffs<F: HardwareField>( &self, eta: Flat<F>, ) -> (Vec<Flat<F>>, Vec<Flat<F>>, Flat<F>)

Ring and whole fold coefficients per slot, trace slots then h slots, and the next-row factor eta^#σ.