Trait binius_core::poly_commit::PolyCommitScheme

pub trait PolyCommitScheme<P, FE>
where
    P: PackedField,
    FE: ExtensionField<P::Scalar>,
{
    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, CH, Backend>(
        &self,
        challenger: &mut CH,
        committed: &Self::Committed,
        polys: &[MultilinearExtension<P, Data>],
        query: &[FE],
        backend: Backend
    ) -> Result<Self::Proof, Self::Error>
       where Data: Deref<Target = [P]> + Send + Sync,
             CH: CanObserve<FE> + CanObserve<Self::Commitment> + CanSample<FE> + CanSampleBits<usize>,
             Backend: ComputationBackend;
    fn verify_evaluation<CH, Backend>(
        &self,
        challenger: &mut CH,
        commitment: &Self::Commitment,
        query: &[FE],
        proof: Self::Proof,
        values: &[FE],
        backend: Backend
    ) -> Result<(), Self::Error>
       where CH: CanObserve<FE> + CanObserve<Self::Commitment> + CanSample<FE> + CanSampleBits<usize>,
             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, CH, Backend>( &self, challenger: &mut CH, committed: &Self::Committed, polys: &[MultilinearExtension<P, Data>], query: &[FE], backend: Backend ) -> Result<Self::Proof, Self::Error>

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

Generate an evaluation proof at a random challenge point.

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

where CH: CanObserve<FE> + CanObserve<Self::Commitment> + CanSample<FE> + CanSampleBits<usize>, 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: Field, FDomain: Field, FE: ExtensionField<F> + ExtensionField<FDomain> + PackedField<Scalar = FE> + PackedExtension<F>, 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, VCS> PolyCommitScheme<P, FExt> for FRIPCS<F, FDomain, FEncode, PE, DomainFactory, VCS>

where F: Field, FDomain: Field, FEncode: BinaryField, FExt: BinaryField + 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, PackedSubfield: PackedFieldIndexable>, DomainFactory: EvaluationDomainFactory<FDomain>, VCS: VectorCommitScheme<FExt> + Sync, VCS::Committed: Send + Sync,

type Commitment = <VCS as VectorCommitScheme<FExt>>::Commitment

type Committed = (Vec<PE>, <VCS as VectorCommitScheme<FExt>>::Committed)

type Proof = Proof<F, FExt, VCS>

type Error = Error

impl<U, F, FA, FI, FE, LC, H, VCS> PolyCommitScheme<<U as PackScalar<F>>::Packed, FE> for TensorPCS<U, F, FA, FI, FE, LC, H, VCS>

where U: PackScalar<F> + PackScalar<FA> + PackScalar<FI, Packed: PackedFieldIndexable> + PackScalar<FE, Packed: PackedFieldIndexable>, F: Field, FA: Field, FI: ExtensionField<F> + ExtensionField<FA>, FE: ExtensionField<F> + ExtensionField<FI>, LC: LinearCode<P = PackedType<U, FA>> + Sync, H: HashDigest<PackedType<U, FI>> + Sync, H::Digest: Copy + Default + Send, VCS: VectorCommitScheme<H::Digest> + Sync,

type Commitment = <VCS as VectorCommitScheme<<H as HashDigest<<U as PackScalar<FI>>::Packed>>::Digest>>::Commitment

type Committed = (Vec<DenseMatrix<<U as PackScalar<FI>>::Packed>>, <VCS as VectorCommitScheme<<H as HashDigest<<U as PackScalar<FI>>::Packed>>::Digest>>::Committed)

type Proof = Proof<U, FI, FE, <VCS as VectorCommitScheme<<H as HashDigest<<U as PackScalar<FI>>::Packed>>::Digest>>::Proof>

type Error = Error