Struct Chip

pub struct Chip<F: Field, A> { /* private fields */ }

An Air that encodes lookups based on interactions.

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, 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

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>, 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 generate_preprocessed_trace( &self, program: &A::Program, ) -> Option<RowMajorMatrix<F>>

Generate the preprocessed trace given a specific program.

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.

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,