Struct BooleanTraceCommitment 

pub struct BooleanTraceCommitment<EF, B> { /* private fields */ }

A commitment to a batch of Boolean trace tables, packed into one bit witness.

The committed object is the bits, so the codeword is as short as the alphabet allows.

The tables themselves are retained, for a prover that evaluates constraints over them.

Implementations

impl<EF, MT, MX> BooleanTraceCommitment<EF, BooleanPcs<EF, MT, MX>>

where EF: ChallengeField<EF> + EncodableLevel + TranscriptField + TowerLevel + FoldAlphabet<EF> + Coordinates, MT: Mmcs<EF>, MX: Mmcs<EF, Error = MT::Error>,

pub fn new( config: BinaryPcsConfig, mmcs: MT, round_mmcs: MX, num_variables: usize, ) -> Result<Self, BooleanTraceError<EF, MT::Error>>

Build a commitment over a batch of tables stacking to num_variables bits.

The arity is the one the layout planner derives from the table shapes.

Errors

Returns an error unless the schedule was derived for the committed alphabet.

Returns an error unless the schedule commits exactly the elements the packing holds.

impl<EF, B> BooleanTraceCommitment<EF, B>

where EF: ChallengeField<EF> + EncodableLevel + TranscriptField + TowerLevel + FoldAlphabet<EF> + Coordinates, B: BooleanBackend<EF>,

pub const fn from_commitment(inner: B) -> Self

Stack trace tables into an already-built bit commitment.

pub fn num_variables(&self) -> usize

Variables the stacked bit witness has, so 2^n bits in all.

Trait Implementations

impl<EF, B, Challenger> MultilinearPcs<EF, Challenger> for BooleanTraceCommitment<EF, B>

where EF: ChallengeField<EF> + EncodableLevel + TranscriptField + TowerLevel + FoldAlphabet<EF> + Coordinates, B: BooleanMultilinearPcs<EF, Challenger>, Challenger: FieldChallenger<EF> + GrindingChallenger<Witness = EF> + CanSampleUniformBits<EF> + CanObserve<B::Commitment>,

type Val = EF

Base field of the committed polynomials.

type Commitment = <B as BooleanBackend<EF>>::Commitment

Succinct binding commitment sent to the verifier.

type ProverData = BooleanTraceCommitmentData<EF, <B as BooleanBackend<EF>>::ProverData>

Prover-side auxiliary data retained between commit and open. Never sent to the verifier.

type Proof = BooleanTraceCommitmentProof<EF, <B as BooleanBackend<EF>>::Proof>

Opening proof checked by the verifier.

type Error = BooleanTraceCommitmentError<<B as BooleanBackend<EF>>::Error>

Verification failure type.

type ProverError = BooleanTraceCommitmentError<<B as BooleanBackend<EF>>::Error>

Configuration or budget failure during commitment or opening.

type Witness = Vec<Table<EF>>

Committed witness.

type OpeningProtocol = OpeningProtocol

Public opening shapes agreed before commit.

fn num_vars(&self) -> usize

Number of variables m of the committed polynomials. Every polynomial has 2^m evaluations.

fn commit( &self, witness: Self::Witness, challenger: &mut Challenger, ) -> Result<(Self::Commitment, Self::ProverData), Self::ProverError>

Commit to a multilinear witness.

fn observe_commitment( &self, commitment: &Self::Commitment, challenger: &mut Challenger, )

Bind a commitment into the transcript.

fn open( &self, prover_data: Self::ProverData, protocol: Self::OpeningProtocol, challenger: &mut Challenger, ) -> Result<Self::Proof, Self::ProverError>

Produce an opening proof for the supplied opening protocol.

fn verify( &self, commitment: &Self::Commitment, proof: &Self::Proof, challenger: &mut Challenger, protocol: Self::OpeningProtocol, ) -> Result<(), Self::Error>

Verify an opening proof against a public commitment and opening protocol.

impl<EF, B, Challenger> PrescribedPointPcs<EF, Challenger> for BooleanTraceCommitment<EF, B>

where EF: ChallengeField<EF> + EncodableLevel + TranscriptField + TowerLevel + FoldAlphabet<EF> + Coordinates, B: BooleanMultilinearPcs<EF, Challenger>, Challenger: FieldChallenger<EF> + GrindingChallenger<Witness = EF> + CanSampleUniformBits<EF> + CanObserve<B::Commitment>,

fn prescribed_security( &self, protocol: &OpeningProtocol, ) -> Option<PrescribedOpeningSecurity>

Soundness evidence for this exact opening protocol, or None when unknown.

fn open_at( &self, prover_data: Self::ProverData, protocol: &OpeningProtocol, points: &[Point<EF>], challenger: &mut Challenger, ) -> Result<Self::Proof, Self::ProverError>

Open the committed columns at caller-prescribed points instead of sampled ones.

fn verify_at( &self, commitment: &Self::Commitment, proof: &Self::Proof, protocol: &OpeningProtocol, points: &[Point<EF>], challenger: &mut Challenger, ) -> Result<Vec<OpeningEvals<EF>>, Self::Error>

Verify a prescribed-point opening and return the opened column values.