Struct CpuColMajorBackend 

pub struct CpuColMajorBackend<SC: StarkProtocolConfig>(/* private fields */);

Implementations

impl<SC: StarkProtocolConfig> CpuColMajorBackend<SC>

pub fn new() -> Self

Trait Implementations

impl<SC: Clone + StarkProtocolConfig> Clone for CpuColMajorBackend<SC>

fn clone(&self) -> CpuColMajorBackend<SC>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<SC: Copy + StarkProtocolConfig> Copy for CpuColMajorBackend<SC>

impl<SC: StarkProtocolConfig> Default for CpuColMajorBackend<SC>

fn default() -> Self

Returns the “default value” for a type.

impl<SC: StarkProtocolConfig> DeviceDataTransporter<SC, CpuColMajorBackend<SC>> for ReferenceDevice<SC>

fn transport_pk_to_device( &self, mpk: &MultiStarkProvingKey<SC>, ) -> DeviceMultiStarkProvingKey<CpuColMajorBackend<SC>>

Transport the proving key to the device, filtering for only the provided air_ids.

fn transport_matrix_to_device( &self, matrix: &ColMajorMatrix<SC::F>, ) -> ColMajorMatrix<SC::F>

fn transport_pcs_data_to_device( &self, pcs_data: &StackedPcsData<SC::F, SC::Digest>, ) -> StackedPcsData<SC::F, SC::Digest>

The commitment and prover_data are assumed to have been previously computed from the trace.

fn transport_matrix_from_device_to_host( &self, matrix: &ColMajorMatrix<SC::F>, ) -> ColMajorMatrix<SC::F>

Transport a device matrix to host. This should only be used for testing / debugging purposes.

fn transport_committed_trace_data_to_device( &self, committed_trace: &CommittedTraceData<CpuColMajorBackend<SC>>, ) -> CommittedTraceData<PB>

fn transport_proving_ctx_to_device( &self, ctx: &ProvingContext<CpuColMajorBackend<SC>>, ) -> ProvingContext<PB>

impl<SC, TS> MultiRapProver<CpuColMajorBackend<SC>, TS> for ReferenceDevice<SC>

where SC: StarkProtocolConfig, SC::EF: TwoAdicField + ExtensionField<SC::F>, TS: FiatShamirTranscript<SC>,

type Artifacts = Vec<<SC as StarkProtocolConfig>::EF>

The random opening point r where the batch constraint sumcheck reduces to evaluation claims of trace matrices T, T_{rot} at r_{n_T}.

type PartialProof = (GkrProof<SC>, BatchConstraintProof<SC>)

The partial proof is the proof that the trace matrices satisfy all constraints assuming that certain polynomial opening claims are validated. In other words, it is a proof that reduces the constraint satisfaction claim to certain polynomial opening claims.

type Error = RefProverError

fn prove_rap_constraints( &self, transcript: &mut TS, mpk: &DeviceMultiStarkProvingKey<CpuColMajorBackend<SC>>, ctx: &ProvingContext<CpuColMajorBackend<SC>>, _common_main_pcs_data: &StackedPcsData<SC::F, SC::Digest>, ) -> Result<((GkrProof<SC>, BatchConstraintProof<SC>), Vec<SC::EF>), Self::Error>

impl<SC, TS> OpeningProver<CpuColMajorBackend<SC>, TS> for ReferenceDevice<SC>

where SC: StarkProtocolConfig, SC::F: Ord, SC::EF: TwoAdicField + ExtensionField<SC::F> + Ord, TS: FiatShamirTranscript<SC>,

type OpeningPoints = Vec<<SC as StarkProtocolConfig>::EF>

The shared vector r where each trace matrix T, T_{rot} is opened at r_{n_T}.

type OpeningProof = (StackingProof<SC>, WhirProof<SC>)

PCS opening proof on host. This should not be a reference.

type Error = RefProverError

Computes the opening proof. The common_main_pcs_data is the PcsData for the collection of common main trace matrices. It is owned by the function and may be mutated. The pre_cached_pcs_data_per_commit is the PcsData for the preprocessed and cached trace matrices. These are specified by their PcsData per commitment.

fn prove_openings( &self, transcript: &mut TS, mpk: &DeviceMultiStarkProvingKey<CpuColMajorBackend<SC>>, ctx: ProvingContext<CpuColMajorBackend<SC>>, common_main_pcs_data: StackedPcsData<SC::F, SC::Digest>, r: Vec<SC::EF>, ) -> Result<(StackingProof<SC>, WhirProof<SC>), Self::Error>

impl<SC: StarkProtocolConfig> ProverBackend for CpuColMajorBackend<SC>

const CHALLENGE_EXT_DEGREE: u8

Extension field degree for the challenge field Self::Challenge over base field Self::Val.

type Val = <SC as StarkProtocolConfig>::F

Base field type, on host.

type Challenge = <SC as StarkProtocolConfig>::EF

Challenge field (extension field of base field), on host.

type Commitment = <SC as StarkProtocolConfig>::Digest

Single commitment on host.

type Matrix = ColMajorMatrix<<SC as StarkProtocolConfig>::F>

Single matrix buffer on device together with dimension metadata. Owning this means nothing else has a shared reference to the buffer.

type OtherAirData = ()

Backend specific type for any pre-computed data associated with a single AIR. For example, it may contain prover-specific precomputations based on the AIR constraints (but independent from any trace data).

type PcsData = StackedPcsData<<SC as StarkProtocolConfig>::F, <SC as StarkProtocolConfig>::Digest>

Owned buffer for the preimage of a PCS commitment on device, together with any metadata necessary for computing opening proofs.

impl<SC, TS> ProverDevice<CpuColMajorBackend<SC>, TS> for ReferenceDevice<SC>

where SC: StarkProtocolConfig, SC::F: Ord, SC::EF: TwoAdicField + ExtensionField<SC::F> + Ord, TS: FiatShamirTranscript<SC>,

type Error = RefProverError

type DeviceCtx = ()

Device-specific context (e.g., CUDA stream). Unit () for CPU devices.

fn device_ctx(&self) -> &()

impl<'a, SC: StarkProtocolConfig> StackedReductionProver<'a, CpuColMajorBackend<SC>, ReferenceDevice<SC>> for StackedReductionCpu<'a, SC>

where SC::F: TwoAdicField, SC::EF: TwoAdicField + ExtensionField<SC::F>, CpuColMajorBackend<SC>: ProverBackend<Val = SC::F, Challenge = SC::EF, PcsData = StackedPcsData<SC::F, SC::Digest>, Matrix = ColMajorMatrix<SC::F>>,

fn new( device: &ReferenceDevice<SC>, stacked_per_commit: Vec<&'a StackedPcsData<SC::F, SC::Digest>>, need_rot_per_commit: Vec<Vec<bool>>, r: &[SC::EF], lambda: SC::EF, ) -> Self

We only provide a view to the stacked PcsData per commitment because the WHIR prover will still use the PLE evaluations of the stacked matrices later. The order of stacked_per_commit is common_main, preprocessed for trace_idx=0 (if any), cached_0 for trace_idx=0, ..., preprocessed for trace_idx=1 (if any), ....

fn batch_sumcheck_uni_round0_poly(&mut self) -> UnivariatePoly<SC::EF>

Return the s_0 batched polynomial from univariate round 0 of sumcheck.

fn fold_ple_evals(&mut self, u_0: SC::EF)

fn batch_sumcheck_poly_eval( &mut self, round: usize, _u_prev: SC::EF, ) -> [SC::EF; 2]

fn fold_mle_evals(&mut self, round: usize, u_round: SC::EF)

fn into_stacked_openings(self) -> Vec<Vec<SC::EF>>

impl<SC: StarkProtocolConfig> TraceCommitter<CpuColMajorBackend<SC>> for ReferenceDevice<SC>

where SC::F: Ord,

type Error = RefProverError

fn commit( &self, traces: &[&ColMajorMatrix<SC::F>], ) -> Result<(SC::Digest, StackedPcsData<SC::F, SC::Digest>), Self::Error>

impl<SC, TS> WhirProver<SC, CpuColMajorBackend<SC>, ReferenceDevice<SC>, TS> for ReferenceDevice<SC>

where SC: StarkProtocolConfig, SC::F: TwoAdicField + Ord, SC::EF: TwoAdicField + ExtensionField<SC::F> + Ord, TS: FiatShamirTranscript<SC>,

type Error = WhirProverError

fn prove_whir( &self, transcript: &mut TS, common_main_pcs_data: StackedPcsData<SC::F, SC::Digest>, pre_cached_pcs_data_per_commit: Vec<Arc<StackedPcsData<SC::F, SC::Digest>>>, u_cube: &[SC::EF], ) -> Result<WhirProof<SC>, WhirProverError>

Prove the WHIR protocol for a collection of MLE polynomials \hat{q}_j, each in n variables, at a single vector u \in \Fext^n.