Struct TrivialPcs 

pub struct TrivialPcs<Val: TwoAdicField, Dft: TwoAdicSubgroupDft<Val>> {
    pub dft: Dft,
    pub log_n: usize,
    pub _phantom: PhantomData<Val>,
}

A trivial PCS: its commitment is simply the coefficients of each poly.

Fields

dft: Dft

log_n: usize

_phantom: PhantomData<Val>

Trait Implementations

impl<Val: Debug + TwoAdicField, Dft: Debug + TwoAdicSubgroupDft<Val>> Debug for TrivialPcs<Val, Dft>

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

Formats the value using the given formatter.

impl<Val, Dft, Challenge, Challenger> Pcs<Challenge, Challenger> for TrivialPcs<Val, Dft>

where Val: TwoAdicField, Challenge: ExtensionField<Val>, Challenger: CanSample<Challenge>, Dft: TwoAdicSubgroupDft<Val>, Vec<Vec<Val>>: Serialize + for<'de> Deserialize<'de>,

const ZK: bool = false

Set to true to activate randomization and achieve zero-knowledge.

type Domain = TwoAdicMultiplicativeCoset<Val>

The class of evaluation domains that this commitment scheme works over.

type Commitment = Vec<Vec<Val>>

The commitment that’s sent to the verifier.

type ProverData = Vec<DenseMatrix<Val>>

Data that the prover stores for committed polynomials, to help the prover with opening.

type EvaluationsOnDomain<'a> = <Dft as TwoAdicSubgroupDft<Val>>::Evaluations

Type of the output of get_evaluations_on_domain.

type Proof = ()

The opening argument.

type Error = ()

The type of a proof verification error.

fn natural_domain_for_degree(&self, degree: usize) -> Self::Domain

This should return a domain such that Domain::next_point returns Some.

fn commit( &self, evaluations: impl IntoIterator<Item = (Self::Domain, RowMajorMatrix<Val>)>, ) -> (Self::Commitment, Self::ProverData)

Given a collection of evaluation matrices, produce a binding commitment to the polynomials defined by those evaluations. If zk is enabled, the evaluations are first randomized as explained in Section 3 of https://eprint.iacr.org/2024/1037.pdf .

fn commit_quotient( &self, quotient_domain: Self::Domain, quotient_evaluations: RowMajorMatrix<Val<Self::Domain>>, num_chunks: usize, ) -> (Self::Commitment, Self::ProverData)

Commit to the quotient polynomial. We first decompose the quotient polynomial into num_chunks many smaller polynomials each of degree degree / num_chunks. This can have minor performance benefits, but is not strictly necessary in the non zk case. When zk is enabled, this commitment will additionally include some randomization process to hide the inputs.

fn get_quotient_ldes( &self, _evaluations: impl IntoIterator<Item = (Self::Domain, RowMajorMatrix<Val>)>, _num_chunks: usize, ) -> Vec<RowMajorMatrix<Val<Self::Domain>>>

When committing to quotient polynomials in batch-STARK, it is simpler to first compute the LDE evaluations before batch-committing to them.

fn commit_ldes( &self, _ldes: Vec<RowMajorMatrix<Val>>, ) -> (Self::Commitment, Self::ProverData)

Commits to a collection of LDE evaluation matrices.

fn get_evaluations_on_domain<'a>( &self, prover_data: &'a Self::ProverData, idx: usize, domain: Self::Domain, ) -> Self::EvaluationsOnDomain<'a>

Given prover data corresponding to a commitment to a collection of evaluation matrices, return the evaluations of those matrices on the given domain.

fn open( &self, rounds: Vec<(&Self::ProverData, Vec<Vec<Challenge>>)>, _challenger: &mut Challenger, ) -> (OpenedValues<Challenge>, Self::Proof)

Open a collection of polynomial commitments at a set of points. Produce the values at those points along with a proof of correctness.

fn verify( &self, rounds: Vec<(Self::Commitment, Vec<(Self::Domain, Vec<(Challenge, Vec<Challenge>)>)>)>, _proof: &Self::Proof, _challenger: &mut Challenger, ) -> Result<(), Self::Error>

Verify that a collection of opened values is correct.

const TRACE_IDX: usize = _

Index of the trace commitment in the computed opened values.

const QUOTIENT_IDX: usize = _

Index of the quotient commitments in the computed opened values.

const PREPROCESSED_TRACE_IDX: usize = _

Index of the preprocessed trace commitment in the computed opened values.

fn commit_preprocessing( &self, evaluations: impl IntoIterator<Item = (Self::Domain, RowMajorMatrix<Val<Self::Domain>>)>, ) -> (Self::Commitment, Self::ProverData)

Same as commit but without randomization. This is used for preprocessed columns which do not have to be randomized even when ZK is enabled. Note that the preprocessed columns still need to be padded to the extended domain height.

fn get_evaluations_on_domain_no_random<'a>( &self, prover_data: &'a Self::ProverData, idx: usize, domain: Self::Domain, ) -> Self::EvaluationsOnDomain<'a>

This is the same as get_evaluations_on_domain but without randomization. This is used for preprocessed columns which do not have to be randomized even when ZK is enabled.

fn open_with_preprocessing( &self, commitment_data_with_opening_points: Vec<(&Self::ProverData, Vec<Vec<Challenge>>)>, fiat_shamir_challenger: &mut Challenger, _is_preprocessing: bool, ) -> (OpenedValues<Challenge>, Self::Proof)

Open a collection of polynomial commitments at a set of points, when there is preprocessing data. It is the same as open when ZK is disabled. Produce the values at those points along with a proof of correctness.

fn get_opt_randomization_poly_commitment( &self, _domain: impl IntoIterator<Item = Self::Domain>, ) -> Option<(Self::Commitment, Self::ProverData)>