Struct Chip

pub struct Chip<F: Field, A> {
    pub air: A,
    pub sends: Vec<Interaction<F>>,
    pub receives: Vec<Interaction<F>>,
    pub log_quotient_degree: usize,
}

An Air that encodes lookups based on interactions.

Fields

air: A

The underlying AIR of the chip for constraint evaluation.

sends: Vec<Interaction<F>>

The interactions that the chip sends.

receives: Vec<Interaction<F>>

The interactions that the chip receives.

log_quotient_degree: usize

The relative log degree of the quotient polynomial, i.e. log2(max_constraint_degree - 1).

Implementations

impl<F: Field, A> Chip<F, A>

pub fn sends(&self) -> &[Interaction<F>]

The send interactions of the chip.

pub fn receives(&self) -> &[Interaction<F>]

The receive interactions of the chip.

pub const fn log_quotient_degree(&self) -> usize

The relative log degree of the quotient polynomial, i.e. log2(max_constraint_degree - 1).

pub fn into_inner(self) -> A

Consumes the chip and returns the underlying air.

impl<F: PrimeField32, A: MachineAir<F>> Chip<F, A>

pub fn included(&self, shard: &A::Record) -> bool

Returns whether the given chip is included in the execution record of the shard.

impl<F, A> Chip<F, A>

where F: Field, A: BaseAir<F>,

pub fn new(air: A) -> Self

where A: MachineAir<F> + Air<InteractionBuilder<F>> + Air<SymbolicAirBuilder<F>>,

Records the interactions and constraint degree from the air and crates a new chip.

pub fn num_interactions(&self) -> usize

Returns the number of interactions in the chip.

pub fn num_sent_byte_lookups(&self) -> usize

Returns the number of sent byte lookups in the chip.

pub fn num_sends_by_kind(&self, kind: InteractionKind) -> usize

Returns the number of sends of the given kind.

pub fn num_receives_by_kind(&self, kind: InteractionKind) -> usize

Returns the number of receives of the given kind.

pub fn generate_permutation_trace<EF: ExtensionField<F>>( &self, preprocessed: Option<&RowMajorMatrix<F>>, main: &RowMajorMatrix<F>, random_elements: &[EF], ) -> (RowMajorMatrix<EF>, EF)

where F: PrimeField, A: MachineAir<F>,

Generates a permutation trace for the given matrix.

pub fn permutation_width(&self) -> usize

Returns the width of the permutation trace.

pub fn cost(&self) -> u64

where A: MachineAir<F>,

Returns the cost of a row in the chip.

pub const fn quotient_width(&self) -> usize

Returns the width of the quotient polynomial.

pub const fn logup_batch_size(&self) -> usize

Returns the log2 of the batch size.

Trait Implementations

impl<'a, F, A, AB> Air<AB> for Chip<F, A>

where F: Field, A: Air<AB> + MachineAir<F>, AB: SP1AirBuilder<F = F> + MultiTableAirBuilder<'a> + PairBuilder + 'a,

fn eval(&self, builder: &mut AB)

impl<F, A> BaseAir<F> for Chip<F, A>

where F: Field, A: BaseAir<F>,

fn width(&self) -> usize

The number of columns (a.k.a. registers) in this AIR.

fn preprocessed_trace(&self) -> Option<RowMajorMatrix<F>>

impl<F, A> Hash for Chip<F, A>

where F: Field, A: Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F, A> MachineAir<F> for Chip<F, A>

where F: Field, A: MachineAir<F>,

type Record = <A as MachineAir<F>>::Record

The execution record containing events for producing the air trace.

type Program = <A as MachineAir<F>>::Program

The program that defines the control flow of the machine.

fn name(&self) -> String

A unique identifier for this AIR as part of a machine.

fn preprocessed_width(&self) -> usize

The width of the preprocessed trace.

fn preprocessed_num_rows( &self, program: &Self::Program, instrs_len: usize, ) -> Option<usize>

The number of rows in the preprocessed trace

fn generate_preprocessed_trace( &self, program: &A::Program, ) -> Option<RowMajorMatrix<F>>

Generate the preprocessed trace given a specific program.

fn num_rows(&self, input: &A::Record) -> Option<usize>

The number of rows in the trace

fn generate_trace( &self, input: &A::Record, output: &mut A::Record, ) -> RowMajorMatrix<F>

Generate the trace for a given execution record.

fn generate_dependencies(&self, input: &A::Record, output: &mut A::Record)

Generate the dependencies for a given execution record.

fn included(&self, shard: &Self::Record) -> bool

Whether this execution record contains events for this air.

fn commit_scope(&self) -> InteractionScope

Specifies whether it’s trace should be part of either the global or local commit.

fn local_only(&self) -> bool

Specifies whether the air only uses the local row, and not the next row.

impl<F, A> PartialEq for Chip<F, A>

where F: Field, A: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F, A: Eq> Eq for Chip<F, A>

where F: Field + Eq,