Trait PolyCommitScheme

pub trait PolyCommitScheme<P, FE>
where
    P: PackedField,
    FE: ExtensionField<P::Scalar> + TowerField,
{
    type Commitment: Clone;
    type Committed;
    type Proof;
    type Error: Error + Send + Sync + 'static;

    // Required methods
    fn n_vars(&self) -> usize;
    fn commit<Data>(
        &self,
        polys: &[MultilinearExtension<P, Data>],
    ) -> Result<(Self::Commitment, Self::Committed), Self::Error>
       where Data: Deref<Target = [P]> + Send + Sync;
    fn prove_evaluation<Data, Transcript, Backend>(
        &self,
        transcript: &mut Transcript,
        committed: &Self::Committed,
        polys: &[MultilinearExtension<P, Data>],
        query: &[FE],
        backend: &Backend,
    ) -> Result<Self::Proof, Self::Error>
       where Data: Deref<Target = [P]> + Send + Sync,
             Transcript: CanObserve<FE> + CanObserve<Self::Commitment> + CanSample<FE> + CanSampleBits<usize> + CanWrite,
             Backend: ComputationBackend;
    fn verify_evaluation<Transcript, Backend>(
        &self,
        transcript: &mut Transcript,
        commitment: &Self::Commitment,
        query: &[FE],
        proof: Self::Proof,
        values: &[FE],
        backend: &Backend,
    ) -> Result<(), Self::Error>
       where Transcript: CanObserve<FE> + CanObserve<Self::Commitment> + CanSample<FE> + CanSampleBits<usize> + CanRead,
             Backend: ComputationBackend;
    fn proof_size(&self, n_polys: usize) -> usize;
}

Required Associated Types

type Commitment: Clone

type Committed

type Proof

type Error: Error + Send + Sync + 'static

Required Methods

fn n_vars(&self) -> usize

fn commit<Data>( &self, polys: &[MultilinearExtension<P, Data>], ) -> Result<(Self::Commitment, Self::Committed), Self::Error>

where Data: Deref<Target = [P]> + Send + Sync,

Commit to a batch of polynomials

fn prove_evaluation<Data, Transcript, Backend>( &self, transcript: &mut Transcript, committed: &Self::Committed, polys: &[MultilinearExtension<P, Data>], query: &[FE], backend: &Backend, ) -> Result<Self::Proof, Self::Error>

where Data: Deref<Target = [P]> + Send + Sync, Transcript: CanObserve<FE> + CanObserve<Self::Commitment> + CanSample<FE> + CanSampleBits<usize> + CanWrite, Backend: ComputationBackend,

Generate an evaluation proof at a random challenge point.

fn verify_evaluation<Transcript, Backend>( &self, transcript: &mut Transcript, commitment: &Self::Commitment, query: &[FE], proof: Self::Proof, values: &[FE], backend: &Backend, ) -> Result<(), Self::Error>

where Transcript: CanObserve<FE> + CanObserve<Self::Commitment> + CanSample<FE> + CanSampleBits<usize> + CanRead, Backend: ComputationBackend,

Verify an evaluation proof at a random challenge point.

fn proof_size(&self, n_polys: usize) -> usize

Return the byte-size of a proof.

Object Safety

This trait is not object safe.

Implementors

impl<F, FDomain, FE, P, PE, DomainFactory, Inner> PolyCommitScheme<P, FE> for RingSwitchPCS<F, FDomain, PE, DomainFactory, Inner>

where F: TowerField, FDomain: Field, FE: ExtensionField<F> + ExtensionField<FDomain> + PackedField<Scalar = FE> + PackedExtension<F> + TowerField, P: PackedField<Scalar = F>, PE: PackedFieldIndexable<Scalar = FE> + PackedExtension<F, PackedSubfield = P> + PackedExtension<FDomain>, DomainFactory: EvaluationDomainFactory<FDomain>, Inner: PolyCommitScheme<PE, FE>,

type Commitment = <Inner as PolyCommitScheme<PE, FE>>::Commitment

type Committed = <Inner as PolyCommitScheme<PE, FE>>::Committed

type Proof = Proof<F, FE, <Inner as PolyCommitScheme<PE, FE>>::Proof>

type Error = Error

impl<F, FDomain, FEncode, FExt, P, PE, DomainFactory, MerkleProver, VCS> PolyCommitScheme<P, FExt> for FRIPCS<F, FDomain, FEncode, PE, DomainFactory, MerkleProver, VCS>

where F: TowerField, FDomain: Field, FEncode: BinaryField, FExt: TowerField + PackedField<Scalar = FExt> + ExtensionField<F> + ExtensionField<FDomain> + ExtensionField<FEncode> + PackedExtension<F> + PackedExtension<FEncode>, P: PackedField<Scalar = F>, PE: PackedFieldIndexable<Scalar = FExt> + PackedExtension<F, PackedSubfield = P> + PackedExtension<FDomain> + PackedExtension<FEncode>, DomainFactory: EvaluationDomainFactory<FDomain>, MerkleProver: MerkleTreeProver<FExt, Scheme = VCS> + Sync, VCS: MerkleTreeScheme<FExt, Digest: Clone + Debug, Proof: Clone + Debug>,

type Commitment = <VCS as MerkleTreeScheme<FExt>>::Digest

type Committed = (Vec<PE>, <MerkleProver as MerkleTreeProver<FExt>>::Committed)

type Proof = Proof<FExt, VCS>

type Error = Error

impl<F, FE, P, Inner> PolyCommitScheme<P, FE> for BatchPCS<P, FE, Inner>

where F: Field, P: PackedField<Scalar = F>, FE: ExtensionField<F> + TowerField, Inner: PolyCommitScheme<P, FE>,

type Commitment = <Inner as PolyCommitScheme<P, FE>>::Commitment

type Committed = <Inner as PolyCommitScheme<P, FE>>::Committed

type Proof = Proof<<Inner as PolyCommitScheme<P, FE>>::Proof>

type Error = Error