From 08be71c20ebf8b5f1696e7ba4dd5c810ef1eb336 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Grzegorz=20=C5=9Awirski?= Date: Sun, 24 Nov 2024 23:01:40 +0100 Subject: [PATCH] Make `Prover` generic over the `ConstraintCommitment` type (#343) --- README.md | 18 +++ examples/src/fibonacci/fib2/prover.rs | 23 ++- examples/src/fibonacci/fib8/prover.rs | 23 ++- examples/src/fibonacci/fib_small/prover.rs | 23 ++- examples/src/fibonacci/mulfib2/prover.rs | 23 ++- examples/src/fibonacci/mulfib8/prover.rs | 23 ++- examples/src/lamport/aggregate/prover.rs | 23 ++- examples/src/lamport/threshold/prover.rs | 23 ++- examples/src/merkle/prover.rs | 23 ++- examples/src/rescue/prover.rs | 23 ++- examples/src/rescue_raps/prover.rs | 22 ++- examples/src/vdf/exempt/prover.rs | 23 ++- examples/src/vdf/regular/prover.rs | 23 ++- prover/README.md | 1 + prover/benches/lagrange_kernel.rs | 22 ++- prover/src/constraints/commitment.rs | 80 ---------- prover/src/constraints/commitment/default.rs | 150 +++++++++++++++++++ prover/src/constraints/commitment/mod.rs | 37 +++++ prover/src/constraints/mod.rs | 2 +- prover/src/lib.rs | 88 ++++------- winterfell/src/lib.rs | 54 +++++-- winterfell/src/tests.rs | 18 +++ 22 files changed, 559 insertions(+), 186 deletions(-) delete mode 100644 prover/src/constraints/commitment.rs create mode 100644 prover/src/constraints/commitment/default.rs create mode 100644 prover/src/constraints/commitment/mod.rs diff --git a/README.md b/README.md index 230146c2b..396cdc5ec 100644 --- a/README.md +++ b/README.md @@ -270,6 +270,8 @@ impl Prover for WorkProver { type TraceLde> = DefaultTraceLde; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, WorkAir, E>; + type ConstraintCommitment> = + DefaultConstraintCommitment; // Our public inputs consist of the first and last value in the execution trace. fn get_pub_inputs(&self, trace: &Self::Trace) -> PublicInputs { @@ -300,6 +302,22 @@ impl Prover for WorkProver { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + // We'll use the default constraint commitment. + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } + fn options(&self) -> &ProofOptions { &self.options } diff --git a/examples/src/fibonacci/fib2/prover.rs b/examples/src/fibonacci/fib2/prover.rs index 99d48f004..28b0ebf53 100644 --- a/examples/src/fibonacci/fib2/prover.rs +++ b/examples/src/fibonacci/fib2/prover.rs @@ -4,9 +4,9 @@ // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -60,6 +60,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -90,4 +92,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/examples/src/fibonacci/fib8/prover.rs b/examples/src/fibonacci/fib8/prover.rs index 64182978c..860eb60df 100644 --- a/examples/src/fibonacci/fib8/prover.rs +++ b/examples/src/fibonacci/fib8/prover.rs @@ -4,9 +4,9 @@ // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -75,6 +75,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -105,4 +107,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/examples/src/fibonacci/fib_small/prover.rs b/examples/src/fibonacci/fib_small/prover.rs index 553988064..9d1ced901 100644 --- a/examples/src/fibonacci/fib_small/prover.rs +++ b/examples/src/fibonacci/fib_small/prover.rs @@ -3,9 +3,9 @@ // This source code is licensed under the MIT license found in the // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -65,6 +65,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -95,4 +97,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/examples/src/fibonacci/mulfib2/prover.rs b/examples/src/fibonacci/mulfib2/prover.rs index 4c99187bf..67aebee70 100644 --- a/examples/src/fibonacci/mulfib2/prover.rs +++ b/examples/src/fibonacci/mulfib2/prover.rs @@ -4,9 +4,9 @@ // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -56,6 +56,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -86,4 +88,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/examples/src/fibonacci/mulfib8/prover.rs b/examples/src/fibonacci/mulfib8/prover.rs index 1fb58bd1a..3cf93aed9 100644 --- a/examples/src/fibonacci/mulfib8/prover.rs +++ b/examples/src/fibonacci/mulfib8/prover.rs @@ -4,9 +4,9 @@ // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -68,6 +68,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -98,4 +100,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/examples/src/lamport/aggregate/prover.rs b/examples/src/lamport/aggregate/prover.rs index 3927a20e6..983eee3fb 100644 --- a/examples/src/lamport/aggregate/prover.rs +++ b/examples/src/lamport/aggregate/prover.rs @@ -6,9 +6,9 @@ #[cfg(feature = "concurrent")] use winterfell::iterators::*; use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -105,6 +105,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -134,6 +136,21 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } // TRACE INITIALIZATION diff --git a/examples/src/lamport/threshold/prover.rs b/examples/src/lamport/threshold/prover.rs index 87bd09bf6..c40f5a9f2 100644 --- a/examples/src/lamport/threshold/prover.rs +++ b/examples/src/lamport/threshold/prover.rs @@ -8,9 +8,9 @@ use std::collections::HashMap; #[cfg(feature = "concurrent")] use winterfell::iterators::*; use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -147,6 +147,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -176,6 +178,21 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } // TRACE INITIALIZATION diff --git a/examples/src/merkle/prover.rs b/examples/src/merkle/prover.rs index b1164ff83..4a86cc90a 100644 --- a/examples/src/merkle/prover.rs +++ b/examples/src/merkle/prover.rs @@ -4,9 +4,9 @@ // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -109,6 +109,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -141,4 +143,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/examples/src/rescue/prover.rs b/examples/src/rescue/prover.rs index e8ca93757..98d725eec 100644 --- a/examples/src/rescue/prover.rs +++ b/examples/src/rescue/prover.rs @@ -4,9 +4,9 @@ // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -75,6 +75,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -108,4 +110,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/examples/src/rescue_raps/prover.rs b/examples/src/rescue_raps/prover.rs index b8b21b1f3..7b04f98b9 100644 --- a/examples/src/rescue_raps/prover.rs +++ b/examples/src/rescue_raps/prover.rs @@ -5,9 +5,9 @@ use core_utils::uninit_vector; use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, }; use super::{ @@ -105,6 +105,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -141,6 +143,20 @@ where DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } fn build_aux_trace( &self, trace: &Self::Trace, diff --git a/examples/src/vdf/exempt/prover.rs b/examples/src/vdf/exempt/prover.rs index 16a7b8169..f39e818d2 100644 --- a/examples/src/vdf/exempt/prover.rs +++ b/examples/src/vdf/exempt/prover.rs @@ -4,9 +4,9 @@ // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -56,6 +56,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -91,4 +93,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/examples/src/vdf/regular/prover.rs b/examples/src/vdf/regular/prover.rs index 20bdf7874..591dcc839 100644 --- a/examples/src/vdf/regular/prover.rs +++ b/examples/src/vdf/regular/prover.rs @@ -4,9 +4,9 @@ // LICENSE file in the root directory of this source tree. use winterfell::{ - crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, ConstraintCompositionCoefficients, - DefaultConstraintEvaluator, DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, - TracePolyTable, TraceTable, + crypto::MerkleTree, matrix::ColMatrix, AuxRandElements, CompositionPoly, CompositionPolyTrace, + ConstraintCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, PartitionOptions, StarkDomain, Trace, TraceInfo, TracePolyTable, TraceTable, }; use super::{ @@ -53,6 +53,8 @@ where type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, Self::Air, E>; @@ -86,4 +88,19 @@ where ) -> Self::ConstraintEvaluator<'a, E> { DefaultConstraintEvaluator::new(air, aux_rand_elements, composition_coefficients) } + + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } } diff --git a/prover/README.md b/prover/README.md index 9c77a9e59..b95a73c0e 100644 --- a/prover/README.md +++ b/prover/README.md @@ -21,6 +21,7 @@ To define a prover for a computation, you'll need implement the `Prover` trait. * `get_pub_inputs()`, which describes how a set of public inputs can be extracted from a given instance of an execution trace. These inputs will need to be shared with the verifier in order for them to verify the proof. * `new_trace_lde()`, which constructs a new instance of trace low-degree extension. Unless your prover needs to implement specialized optimizations for performing low-degree extensions, this method can just return a default trace low-degree extension provided by Winterfell. * `new_evaluator()`, which constructs a new instance of the AIR constraint evaluator. Unless your prover needs to implement specialized optimizations for evaluating constraints, this method can just return a default constraint evaluator provided by Winterfell. +* `build_constraint_commitment()`, which constructs a new instance of constraint commitment. Unless your prover needs to implement specialized optimizations for committing to constraints, this method can just return a default constraint commitment provided by Winterfell. * `options()`, which defines STARK protocol parameters to be used during proof generation. These parameters include number of queries, blowup factor, grinding factor, hash function to be used during proof generation etc.. Values of these parameters directly inform such metrics as proof generation time, proof size, and proof security level. See [air crate](../air) for more info. A prover exposes a `prove()` method which can be used to generate a STARK proof using a given execution trace as a witness. diff --git a/prover/benches/lagrange_kernel.rs b/prover/benches/lagrange_kernel.rs index d6ab6a5bc..92bf54f5a 100644 --- a/prover/benches/lagrange_kernel.rs +++ b/prover/benches/lagrange_kernel.rs @@ -14,8 +14,9 @@ use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criteri use crypto::{hashers::Blake3_256, DefaultRandomCoin, MerkleTree, RandomCoin}; use math::{fields::f64::BaseElement, ExtensionOf, FieldElement}; use winter_prover::{ - matrix::ColMatrix, DefaultConstraintEvaluator, DefaultTraceLde, Prover, ProverGkrProof, - StarkDomain, Trace, TracePolyTable, + matrix::ColMatrix, CompositionPoly, CompositionPolyTrace, DefaultConstraintCommitment, + DefaultConstraintEvaluator, DefaultTraceLde, Prover, ProverGkrProof, StarkDomain, Trace, + TracePolyTable, }; const TRACE_LENS: [usize; 2] = [2_usize.pow(16), 2_usize.pow(20)]; @@ -187,6 +188,8 @@ impl Prover for LagrangeProver { type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, LagrangeKernelAir, E>; @@ -210,6 +213,21 @@ impl Prover for LagrangeProver { DefaultTraceLde::new(trace_info, main_trace, domain, partition_option) } + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } + fn new_evaluator<'a, E>( &self, air: &'a Self::Air, diff --git a/prover/src/constraints/commitment.rs b/prover/src/constraints/commitment.rs deleted file mode 100644 index ac71fdc94..000000000 --- a/prover/src/constraints/commitment.rs +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright (c) Facebook, Inc. and its affiliates. -// -// This source code is licensed under the MIT license found in the -// LICENSE file in the root directory of this source tree. - -use alloc::vec::Vec; -use core::marker::PhantomData; - -use air::proof::Queries; -use crypto::{ElementHasher, VectorCommitment}; -use math::FieldElement; - -use super::RowMatrix; - -// CONSTRAINT COMMITMENT -// ================================================================================================ - -/// Constraint evaluation commitment. -/// -/// The commitment consists of two components: -/// * Evaluations of composition polynomial columns over the LDE domain. -/// * Vector commitment where each vector element corresponds to the digest of a row in -/// the composition polynomial evaluation matrix. -pub struct ConstraintCommitment< - E: FieldElement, - H: ElementHasher, - V: VectorCommitment, -> { - evaluations: RowMatrix, - vector_commitment: V, - _h: PhantomData, -} - -impl ConstraintCommitment -where - E: FieldElement, - H: ElementHasher, - V: VectorCommitment, -{ - /// Creates a new constraint evaluation commitment from the provided composition polynomial - /// evaluations and the corresponding vector commitment. - pub fn new(evaluations: RowMatrix, commitment: V) -> ConstraintCommitment { - assert_eq!( - evaluations.num_rows(), - commitment.domain_len(), - "number of rows in constraint evaluation matrix must be the same as the size \ - of the vector commitment domain" - ); - - ConstraintCommitment { - evaluations, - vector_commitment: commitment, - _h: PhantomData, - } - } - - /// Returns the commitment. - pub fn commitment(&self) -> H::Digest { - self.vector_commitment.commitment() - } - - /// Returns constraint evaluations at the specified positions along with a batch opening proof - /// against the vector commitment. - pub fn query(self, positions: &[usize]) -> Queries { - // build batch opening proof to the leaves specified by positions - let opening_proof = self - .vector_commitment - .open_many(positions) - .expect("failed to generate a batch opening proof for constraint queries"); - - // determine a set of evaluations corresponding to each position - let mut evaluations = Vec::new(); - for &position in positions { - let row = self.evaluations.row(position).to_vec(); - evaluations.push(row); - } - - Queries::new::(opening_proof.1, evaluations) - } -} diff --git a/prover/src/constraints/commitment/default.rs b/prover/src/constraints/commitment/default.rs new file mode 100644 index 000000000..629c08cd3 --- /dev/null +++ b/prover/src/constraints/commitment/default.rs @@ -0,0 +1,150 @@ +// Copyright (c) Facebook, Inc. and its affiliates. +// +// This source code is licensed under the MIT license found in the +// LICENSE file in the root directory of this source tree. + +use alloc::vec::Vec; +use core::marker::PhantomData; + +use air::{proof::Queries, PartitionOptions}; +use crypto::{ElementHasher, VectorCommitment}; +use math::FieldElement; +use tracing::info_span; + +use super::{ConstraintCommitment, RowMatrix}; +use crate::{CompositionPoly, CompositionPolyTrace, StarkDomain, DEFAULT_SEGMENT_WIDTH}; + +// CONSTRAINT COMMITMENT +// ================================================================================================ + +/// Constraint evaluation commitment. +/// +/// The commitment consists of two components: +/// * Evaluations of composition polynomial columns over the LDE domain. +/// * Vector commitment where each vector element corresponds to the digest of a row in +/// the composition polynomial evaluation matrix. +pub struct DefaultConstraintCommitment< + E: FieldElement, + H: ElementHasher, + V: VectorCommitment, +> { + evaluations: RowMatrix, + vector_commitment: V, + _h: PhantomData, +} + +impl DefaultConstraintCommitment +where + E: FieldElement, + H: ElementHasher, + V: VectorCommitment, +{ + /// Creates a new constraint evaluation commitment from the provided composition polynomial + /// evaluations and the corresponding vector commitment. + pub fn new( + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self, CompositionPoly) { + // extend the main execution trace and build a commitment to the extended trace + let (evaluations, commitment, composition_poly) = build_constraint_commitment::( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ); + + assert_eq!( + evaluations.num_rows(), + commitment.domain_len(), + "number of rows in constraint evaluation matrix must be the same as the size \ + of the vector commitment domain" + ); + + let commitment = Self { + evaluations, + vector_commitment: commitment, + _h: PhantomData, + }; + + (commitment, composition_poly) + } +} + +impl ConstraintCommitment for DefaultConstraintCommitment +where + E: FieldElement, + H: ElementHasher + core::marker::Sync, + V: VectorCommitment + core::marker::Sync, +{ + type HashFn = H; + type VC = V; + + /// Returns the commitment. + fn commitment(&self) -> H::Digest { + self.vector_commitment.commitment() + } + + /// Returns constraint evaluations at the specified positions along with a batch opening proof + /// against the vector commitment. + fn query(self, positions: &[usize]) -> Queries { + // build batch opening proof to the leaves specified by positions + let opening_proof = self + .vector_commitment + .open_many(positions) + .expect("failed to generate a batch opening proof for constraint queries"); + + // determine a set of evaluations corresponding to each position + let mut evaluations = Vec::new(); + for &position in positions { + let row = self.evaluations.row(position).to_vec(); + evaluations.push(row); + } + + Queries::new::(opening_proof.1, evaluations) + } +} + +fn build_constraint_commitment( + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, +) -> (RowMatrix, V, CompositionPoly) +where + E: FieldElement, + H: ElementHasher, + V: VectorCommitment, +{ + // first, build constraint composition polynomial from its trace as follows: + // - interpolate the trace into a polynomial in coefficient form + // - "break" the polynomial into a set of column polynomials each of degree equal to + // trace_length - 1 + let composition_poly = info_span!( + "build_composition_poly_columns", + num_columns = num_constraint_composition_columns + ) + .in_scope(|| { + CompositionPoly::new(composition_poly_trace, domain, num_constraint_composition_columns) + }); + assert_eq!(composition_poly.num_columns(), num_constraint_composition_columns); + assert_eq!(composition_poly.column_degree(), domain.trace_length() - 1); + + // then, evaluate composition polynomial columns over the LDE domain + let domain_size = domain.lde_domain_size(); + let composed_evaluations = info_span!("evaluate_composition_poly_columns").in_scope(|| { + RowMatrix::evaluate_polys_over::(composition_poly.data(), domain) + }); + assert_eq!(composed_evaluations.num_cols(), num_constraint_composition_columns); + assert_eq!(composed_evaluations.num_rows(), domain_size); + + // finally, build constraint evaluation commitment + let commitment = info_span!( + "compute_constraint_evaluation_commitment", + log_domain_size = domain_size.ilog2() + ) + .in_scope(|| composed_evaluations.commit_to_rows::(partition_options)); + + (composed_evaluations, commitment, composition_poly) +} diff --git a/prover/src/constraints/commitment/mod.rs b/prover/src/constraints/commitment/mod.rs new file mode 100644 index 000000000..5ecfe8b08 --- /dev/null +++ b/prover/src/constraints/commitment/mod.rs @@ -0,0 +1,37 @@ +// Copyright (c) Facebook, Inc. and its affiliates. +// +// This source code is licensed under the MIT license found in the +// LICENSE file in the root directory of this source tree. + +use air::proof::Queries; +use crypto::{ElementHasher, Hasher, VectorCommitment}; +use math::FieldElement; + +use super::RowMatrix; + +mod default; +pub use default::DefaultConstraintCommitment; + +// CONSTRAINT COMMITMENT +// ================================================================================================ + +/// Constraint evaluation commitment. +/// +/// The commitment consists of two components: +/// * Evaluations of composition polynomial columns over the LDE domain. +/// * Vector commitment where each vector element corresponds to the digest of a row in +/// the composition polynomial evaluation matrix. +pub trait ConstraintCommitment { + /// The hash function used for hashing the rows of trace segment LDEs. + type HashFn: ElementHasher; + + /// The vector commitment scheme used for commiting to the trace. + type VC: VectorCommitment; + + /// Returns the commitment. + fn commitment(&self) -> ::Digest; + + /// Returns constraint evaluations at the specified positions along with a batch opening proof + /// against the vector commitment. + fn query(self, positions: &[usize]) -> Queries; +} diff --git a/prover/src/constraints/mod.rs b/prover/src/constraints/mod.rs index 566065f0f..054edb32c 100644 --- a/prover/src/constraints/mod.rs +++ b/prover/src/constraints/mod.rs @@ -15,4 +15,4 @@ mod evaluation_table; pub use evaluation_table::{ConstraintEvaluationTable, EvaluationTableFragment}; mod commitment; -pub use commitment::ConstraintCommitment; +pub use commitment::{ConstraintCommitment, DefaultConstraintCommitment}; diff --git a/prover/src/lib.rs b/prover/src/lib.rs index 6854ae818..906fac8ec 100644 --- a/prover/src/lib.rs +++ b/prover/src/lib.rs @@ -73,7 +73,7 @@ use matrix::{ColMatrix, RowMatrix}; mod constraints; pub use constraints::{ CompositionPoly, CompositionPolyTrace, ConstraintCommitment, ConstraintEvaluator, - DefaultConstraintEvaluator, + DefaultConstraintCommitment, DefaultConstraintEvaluator, }; mod composer; @@ -155,6 +155,12 @@ pub trait Prover { where E: FieldElement; + /// Constraint low-degree extension for building the LDEs of composition polynomial columns and + /// their commitments. + type ConstraintCommitment: ConstraintCommitment + where + E: FieldElement; + // REQUIRED METHODS // -------------------------------------------------------------------------------------------- @@ -199,6 +205,27 @@ pub trait Prover { where E: FieldElement; + /// Extends constraint composition polynomial over the LDE domain and builds a commitment to + /// its evaluations. + /// + /// The extension is done by first interpolating the evaluations of the polynomial so that we + /// get the composition polynomial in coefficient form; then breaking the polynomial into + /// columns each of size equal to trace length, and finally evaluating each composition + /// polynomial column over the LDE domain. + /// + /// The commitment is computed by building a vector containing the hashes of each row in + /// the evaluation matrix, and then building vector commitment of the resulting vector. + #[maybe_async] + fn build_constraint_commitment( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) + where + E: FieldElement; + // PROVIDED METHODS // -------------------------------------------------------------------------------------------- @@ -508,62 +535,6 @@ pub trait Prover { Ok(proof) } - /// Extends constraint composition polynomial over the LDE domain and builds a commitment to - /// its evaluations. - /// - /// The extension is done by first interpolating the evaluations of the polynomial so that we - /// get the composition polynomial in coefficient form; then breaking the polynomial into - /// columns each of size equal to trace length, and finally evaluating each composition - /// polynomial column over the LDE domain. - /// - /// The commitment is computed by building a vector containing the hashes of each row in - /// the evaluation matrix, and then building vector commitment of the resulting vector. - #[maybe_async] - fn build_constraint_commitment( - &self, - composition_poly_trace: CompositionPolyTrace, - num_constraint_composition_columns: usize, - domain: &StarkDomain, - ) -> (ConstraintCommitment, CompositionPoly) - where - E: FieldElement, - { - // first, build constraint composition polynomial from its trace as follows: - // - interpolate the trace into a polynomial in coefficient form - // - "break" the polynomial into a set of column polynomials each of degree equal to - // trace_length - 1 - let composition_poly = info_span!( - "build_composition_poly_columns", - num_columns = num_constraint_composition_columns - ) - .in_scope(|| { - CompositionPoly::new(composition_poly_trace, domain, num_constraint_composition_columns) - }); - assert_eq!(composition_poly.num_columns(), num_constraint_composition_columns); - assert_eq!(composition_poly.column_degree(), domain.trace_length() - 1); - - // then, evaluate composition polynomial columns over the LDE domain - let domain_size = domain.lde_domain_size(); - let composed_evaluations = info_span!("evaluate_composition_poly_columns").in_scope(|| { - RowMatrix::evaluate_polys_over::(composition_poly.data(), domain) - }); - assert_eq!(composed_evaluations.num_cols(), num_constraint_composition_columns); - assert_eq!(composed_evaluations.num_rows(), domain_size); - - // finally, build constraint evaluation commitment - let constraint_commitment = info_span!( - "compute_constraint_evaluation_commitment", - log_domain_size = domain_size.ilog2() - ) - .in_scope(|| { - let commitment = composed_evaluations - .commit_to_rows::(self.options().partition_options()); - ConstraintCommitment::new(composed_evaluations, commitment) - }); - - (constraint_commitment, composition_poly) - } - #[doc(hidden)] #[instrument(skip_all)] #[maybe_async] @@ -603,7 +574,7 @@ pub trait Prover { composition_poly_trace: CompositionPolyTrace, domain: &StarkDomain, channel: &mut ProverChannel<'_, Self::Air, E, Self::HashFn, Self::RandomCoin, Self::VC>, - ) -> (ConstraintCommitment, CompositionPoly) + ) -> (Self::ConstraintCommitment, CompositionPoly) where E: FieldElement, { @@ -614,6 +585,7 @@ pub trait Prover { composition_poly_trace, air.context().num_constraint_composition_columns(), domain, + self.options().partition_options() )); // then, commit to the evaluations of constraints by writing the commitment string of diff --git a/winterfell/src/lib.rs b/winterfell/src/lib.rs index e05d5ca5c..3e06ebb96 100644 --- a/winterfell/src/lib.rs +++ b/winterfell/src/lib.rs @@ -261,7 +261,9 @@ //! crypto::{hashers::Blake3_256, DefaultRandomCoin, MerkleTree}, //! math::{fields::f128::BaseElement, FieldElement, ToElements}, //! matrix::ColMatrix, -//! DefaultTraceLde, ProofOptions, Prover, StarkDomain, Trace, TracePolyTable, TraceTable, +//! CompositionPoly, CompositionPolyTrace, DefaultConstraintCommitment, +//! DefaultTraceLde, ProofOptions, Prover, StarkDomain, Trace, +//! TracePolyTable, TraceTable, //! }; //! //! # use winterfell::{ @@ -350,6 +352,8 @@ //! type VC = MerkleTree; //! type RandomCoin = DefaultRandomCoin; //! type TraceLde> = DefaultTraceLde; +//! type ConstraintCommitment> = +//! DefaultConstraintCommitment; //! type ConstraintEvaluator<'a, E: FieldElement> = //! DefaultConstraintEvaluator<'a, Self::Air, E>; //! @@ -376,6 +380,21 @@ //! DefaultTraceLde::new(trace_info, main_trace, domain, partition_option) //! } //! +//! fn build_constraint_commitment>( +//! &self, +//! composition_poly_trace: CompositionPolyTrace, +//! num_constraint_composition_columns: usize, +//! domain: &StarkDomain, +//! partition_options: PartitionOptions, +//! ) -> (Self::ConstraintCommitment, CompositionPoly) { +//! DefaultConstraintCommitment::new( +//! composition_poly_trace, +//! num_constraint_composition_columns, +//! domain, +//! partition_options, +//! ) +//! } +//! //! fn new_evaluator<'a, E: FieldElement>( //! &self, //! air: &'a Self::Air, @@ -399,9 +418,9 @@ //! # crypto::{hashers::Blake3_256, DefaultRandomCoin, MerkleTree}, //! # math::{fields::f128::BaseElement, FieldElement, ToElements}, //! # matrix::ColMatrix, -//! # Air, AirContext, Assertion, AuxRandElements, ByteWriter, DefaultConstraintEvaluator, -//! # DefaultTraceLde, EvaluationFrame, TraceInfo, -//! # TransitionConstraintDegree, TraceTable, FieldExtension, PartitionOptions, Prover, +//! # Air, AirContext, Assertion, AuxRandElements, ByteWriter, CompositionPoly, CompositionPolyTrace, +//! # DefaultConstraintEvaluator, DefaultConstraintCommitment, DefaultTraceLde, EvaluationFrame, +//! # TraceInfo, TransitionConstraintDegree, TraceTable, FieldExtension, PartitionOptions, Prover, //! # ProofOptions, StarkDomain, Proof, Trace, TracePolyTable, //! # }; //! # @@ -495,6 +514,8 @@ //! # type VC = MerkleTree; //! # type RandomCoin = DefaultRandomCoin; //! # type TraceLde> = DefaultTraceLde; +//! # type ConstraintCommitment> = +//! # DefaultConstraintCommitment; //! # type ConstraintEvaluator<'a, E: FieldElement> = //! # DefaultConstraintEvaluator<'a, Self::Air, E>; //! # @@ -520,6 +541,21 @@ //! # DefaultTraceLde::new(trace_info, main_trace, domain, partition_option) //! # } //! # +//! # fn build_constraint_commitment>( +//! # &self, +//! # composition_poly_trace: CompositionPolyTrace, +//! # num_constraint_composition_columns: usize, +//! # domain: &StarkDomain, +//! # partition_options: PartitionOptions, +//! # ) -> (Self::ConstraintCommitment, CompositionPoly) { +//! # DefaultConstraintCommitment::new( +//! # composition_poly_trace, +//! # num_constraint_composition_columns, +//! # domain, +//! # partition_options, +//! # ) +//! # } +//! # //! # fn new_evaluator<'a, E: FieldElement>( //! # &self, //! # air: &'a Self::Air, @@ -599,12 +635,12 @@ extern crate std; pub use air::{AuxRandElements, GkrVerifier, PartitionOptions}; pub use prover::{ crypto, iterators, math, matrix, Air, AirContext, Assertion, AuxTraceWithMetadata, - BoundaryConstraint, BoundaryConstraintGroup, CompositionPolyTrace, + BoundaryConstraint, BoundaryConstraintGroup, CompositionPoly, CompositionPolyTrace, ConstraintCompositionCoefficients, ConstraintDivisor, ConstraintEvaluator, - DeepCompositionCoefficients, DefaultConstraintEvaluator, DefaultTraceLde, EvaluationFrame, - FieldExtension, Proof, ProofOptions, Prover, ProverError, ProverGkrProof, StarkDomain, Trace, - TraceInfo, TraceLde, TracePolyTable, TraceTable, TraceTableFragment, - TransitionConstraintDegree, + DeepCompositionCoefficients, DefaultConstraintCommitment, DefaultConstraintEvaluator, + DefaultTraceLde, EvaluationFrame, FieldExtension, Proof, ProofOptions, Prover, ProverError, + ProverGkrProof, StarkDomain, Trace, TraceInfo, TraceLde, TracePolyTable, TraceTable, + TraceTableFragment, TransitionConstraintDegree, }; pub use verifier::{verify, AcceptableOptions, ByteWriter, VerifierError}; diff --git a/winterfell/src/tests.rs b/winterfell/src/tests.rs index 3fb0c5197..c1ae685e9 100644 --- a/winterfell/src/tests.rs +++ b/winterfell/src/tests.rs @@ -11,6 +11,7 @@ use prover::{ crypto::{hashers::Blake3_256, DefaultRandomCoin, RandomCoin}, math::{fields::f64::BaseElement, ExtensionOf, FieldElement}, matrix::ColMatrix, + CompositionPoly, DefaultConstraintCommitment, }; use super::*; @@ -219,6 +220,8 @@ impl Prover for LagrangeComplexProver { type RandomCoin = DefaultRandomCoin; type TraceLde> = DefaultTraceLde; + type ConstraintCommitment> = + DefaultConstraintCommitment, Self::VC>; type ConstraintEvaluator<'a, E: FieldElement> = DefaultConstraintEvaluator<'a, LagrangeKernelComplexAir, E>; @@ -242,6 +245,21 @@ impl Prover for LagrangeComplexProver { DefaultTraceLde::new(trace_info, main_trace, domain, partition_option) } + fn build_constraint_commitment>( + &self, + composition_poly_trace: CompositionPolyTrace, + num_constraint_composition_columns: usize, + domain: &StarkDomain, + partition_options: PartitionOptions, + ) -> (Self::ConstraintCommitment, CompositionPoly) { + DefaultConstraintCommitment::new( + composition_poly_trace, + num_constraint_composition_columns, + domain, + partition_options, + ) + } + fn new_evaluator<'a, E>( &self, air: &'a Self::Air,