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

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_opt_randomization_poly_commitment( &self, _domain: Self::Domain, ) -> Option<(Self::Commitment, Self::ProverData)>