Struct PackedStack 

pub struct PackedStack<A, EF> { /* private fields */ }

Equal-height columns over a narrow alphabet, held as the elements a commitment takes.

Overview

Each column packs on its own, so a column boundary lands on an element boundary.

    elements   [ column 0 ][ column 1 ] ... [ column k-1 ]
    column     2^arity elements, each holding d / a cells

That is what a stacked commitment expects of a source table. Nothing moves between the two.

Implementations

impl<A, EF> PackedStack<A, EF>

where A: Coordinates, EF: Coordinates + TowerLevel,

pub const CELLS_PER_ELEMENT: usize

Cells one wide element absorbs.

pub fn from_columns(columns: &[&[A]]) -> Result<Self, PackError>

Pack equal-height columns, lowest column first.

Errors

• The alphabet is wider than the level packing it, so no cell fits.
• No column was supplied, so there is nothing to commit.
• The columns have different heights, so the layout has no common arity.
• A column’s cells do not fill a whole number of elements.
• A packed column is no power-of-two length, so it covers no hypercube.

pub fn elements(&self) -> &[EF]

Every column’s elements, lowest column first.

pub const fn num_columns(&self) -> usize

Source columns the stack holds.

pub const fn column_num_variables(&self) -> usize

Variables one packed column’s multilinear has.

pub const fn column_num_cells(&self) -> usize

Cells one source column held.

pub fn column(&self, index: usize) -> &[EF]

One packed column’s elements, panicking on a column the stack does not hold.

pub fn locate(&self, column: usize, cell: usize) -> (usize, usize)

Which element of the stack, and which cell inside it, one source cell landed in.

This is the view an opening reads, since a claim lands on the committed polynomial.

Panics

Panics if the column or the cell is not one the stack holds.

pub fn cell(&self, column: usize, cell: usize) -> A

One source cell, read back out of the element holding it.

pub fn unpack_column(&self, index: usize) -> Vec<A>

One source column, read back in full.

pub fn into_poly(self) -> Poly<EF>

The stack as the multilinear a single-column commitment holds.

pub fn into_table(self) -> Table<EF>

The stack as one source table of a commitment’s stacked layout.

Row i of the table is packed column i, the orientation that layout reads.

impl<U, EF> PackedStack<PackedGf2<U>, EF>

where U: Underlier, EF: Coordinates + TowerLevel,

pub fn from_bit_rows( rows: &[PackedGf2<U>], num_columns: usize, ) -> Result<Self, PackError>

Pack a bit-sliced block whose lanes are columns rather than rows.

    in     row r    ->  lanes are columns 0 .. d
    out    column c ->  lanes are the rows of one block

One square bit transpose per block of d rows, so whole words move at a time.

Arguments

• rows: one block per row, in row order, covering whole blocks.
• num_columns: leading lanes to keep, the rest being unused width.

Errors

• The rows are no whole number of square blocks, or ask for more than a block’s lanes.
• The transposed columns do not pack, for any of the reasons columns can fail to.

Trait Implementations

impl<A: Clone, EF: Clone> Clone for PackedStack<A, EF>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug, EF: Debug> Debug for PackedStack<A, EF>

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

Formats the value using the given formatter.

impl<A: Eq, EF: Eq> Eq for PackedStack<A, EF>

impl<A: PartialEq, EF: PartialEq> PartialEq for PackedStack<A, EF>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<A: PartialEq, EF: PartialEq> StructuralPartialEq for PackedStack<A, EF>