Struct sp1_core::stark::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).

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,

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

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

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

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

where F: PrimeField,

pub fn permutation_width(&self) -> usize

pub const fn quotient_width(&self) -> usize

pub const fn logup_batch_size(&self) -> usize

Trait Implementations

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

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

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

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.

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

where F: Field, A: PartialEq,

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

This method tests for self and other values to be equal, and is used by ==.

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

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