Trait Mmcs

pub trait Mmcs<T: Send + Sync>: Clone {
    type ProverData<M>;
    type Commitment: Clone + Serialize + DeserializeOwned;
    type Proof: Clone + Serialize + DeserializeOwned;
    type Error: Debug;

    // Required methods
    fn commit<M: Matrix<T>>(
        &self,
        inputs: Vec<M>,
    ) -> (Self::Commitment, Self::ProverData<M>);
    fn open_batch<M: Matrix<T>>(
        &self,
        index: usize,
        prover_data: &Self::ProverData<M>,
    ) -> (Vec<Vec<T>>, Self::Proof);
    fn get_matrices<'a, M: Matrix<T>>(
        &self,
        prover_data: &'a Self::ProverData<M>,
    ) -> Vec<&'a M>;
    fn verify_batch(
        &self,
        commit: &Self::Commitment,
        dimensions: &[Dimensions],
        index: usize,
        opened_values: &[Vec<T>],
        proof: &Self::Proof,
    ) -> Result<(), Self::Error>;

    // Provided methods
    fn commit_matrix<M: Matrix<T>>(
        &self,
        input: M,
    ) -> (Self::Commitment, Self::ProverData<M>) { ... }
    fn commit_vec(
        &self,
        input: Vec<T>,
    ) -> (Self::Commitment, Self::ProverData<RowMajorMatrix<T>>)
       where T: Clone + Send + Sync { ... }
    fn get_matrix_heights<M: Matrix<T>>(
        &self,
        prover_data: &Self::ProverData<M>,
    ) -> Vec<usize> { ... }
    fn get_max_height<M: Matrix<T>>(
        &self,
        prover_data: &Self::ProverData<M>,
    ) -> usize { ... }
}

A “Mixed Matrix Commitment Scheme” (MMCS) is a generalization of a vector commitment scheme.

It supports committing to matrices and then opening rows. It is also batch-oriented; one can commit to a batch of matrices at once even if their widths and heights differ.

When a particular row index is opened, it is interpreted directly as a row index for matrices with the largest height. For matrices with smaller heights, some bits of the row index are removed (from the least-significant side) to get the effective row index. These semantics are useful in the FRI protocol. See the documentation for open_batch for more details.

Required Associated Types

type ProverData<M>

type Commitment: Clone + Serialize + DeserializeOwned

type Proof: Clone + Serialize + DeserializeOwned

type Error: Debug

Required Methods

fn commit<M: Matrix<T>>( &self, inputs: Vec<M>, ) -> (Self::Commitment, Self::ProverData<M>)

fn open_batch<M: Matrix<T>>( &self, index: usize, prover_data: &Self::ProverData<M>, ) -> (Vec<Vec<T>>, Self::Proof)

Opens a batch of rows from committed matrices returns (openings, proof) where openings is a vector whose ith element is the jth row of the ith matrix M[i], and j = index >> (log2_ceil(max_height) - log2_ceil(M[i].height)).

fn get_matrices<'a, M: Matrix<T>>( &self, prover_data: &'a Self::ProverData<M>, ) -> Vec<&'a M>

Get the matrices that were committed to.

fn verify_batch( &self, commit: &Self::Commitment, dimensions: &[Dimensions], index: usize, opened_values: &[Vec<T>], proof: &Self::Proof, ) -> Result<(), Self::Error>

Verify a batch opening. index is the row index we’re opening for each matrix, following the same semantics as open_batch. dimensions is a slice whose ith element is the dimensions of the matrix being opened in the ith opening

Provided Methods

fn commit_matrix<M: Matrix<T>>( &self, input: M, ) -> (Self::Commitment, Self::ProverData<M>)

fn commit_vec( &self, input: Vec<T>, ) -> (Self::Commitment, Self::ProverData<RowMajorMatrix<T>>)

where T: Clone + Send + Sync,

fn get_matrix_heights<M: Matrix<T>>( &self, prover_data: &Self::ProverData<M>, ) -> Vec<usize>

fn get_max_height<M: Matrix<T>>( &self, prover_data: &Self::ProverData<M>, ) -> usize

Get the largest height of any committed matrix.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<F, EF, InnerMmcs> Mmcs<EF> for ExtensionMmcs<F, EF, InnerMmcs>

where F: Field, EF: ExtensionField<F>, InnerMmcs: Mmcs<F>,

type ProverData<M> = <InnerMmcs as Mmcs<F>>::ProverData<FlatMatrixView<F, EF, M>>

type Commitment = <InnerMmcs as Mmcs<F>>::Commitment

type Proof = <InnerMmcs as Mmcs<F>>::Proof

type Error = <InnerMmcs as Mmcs<F>>::Error

impl<P, PW, H, C, R, const DIGEST_ELEMS: usize, const SALT_ELEMS: usize> Mmcs<<P as PackedValue>::Value> for MerkleTreeHidingMmcs<P, PW, H, C, R, DIGEST_ELEMS, SALT_ELEMS>

where P: PackedValue, P::Value: Serialize + DeserializeOwned, PW: PackedValue, H: CryptographicHasher<P::Value, [PW::Value; DIGEST_ELEMS]> + CryptographicHasher<P, [PW; DIGEST_ELEMS]> + Sync, C: PseudoCompressionFunction<[PW::Value; DIGEST_ELEMS], 2> + PseudoCompressionFunction<[PW; DIGEST_ELEMS], 2> + Sync, R: Rng + Clone, PW::Value: Eq, [PW::Value; DIGEST_ELEMS]: Serialize + for<'de> Deserialize<'de>, Standard: Distribution<P::Value>,

impl<P, PW, H, C, const DIGEST_ELEMS: usize> Mmcs<<P as PackedValue>::Value> for MerkleTreeMmcs<P, PW, H, C, DIGEST_ELEMS>

where P: PackedValue, PW: PackedValue, H: CryptographicHasher<P::Value, [PW::Value; DIGEST_ELEMS]> + CryptographicHasher<P, [PW; DIGEST_ELEMS]> + Sync, C: PseudoCompressionFunction<[PW::Value; DIGEST_ELEMS], 2> + PseudoCompressionFunction<[PW; DIGEST_ELEMS], 2> + Sync, PW::Value: Eq, [PW::Value; DIGEST_ELEMS]: Serialize + for<'de> Deserialize<'de>,