From 31a811ede0f14c74c5560a1b045996ad525799ec Mon Sep 17 00:00:00 2001 From: Ian Joiner <14581281+iajoiner@users.noreply.github.com> Date: Tue, 3 Dec 2024 20:25:26 -0500 Subject: [PATCH] refactor!: merge `result_evaluate` back to `first_round_evaluate` --- .../proof-of-sql/src/sql/proof/proof_plan.rs | 8 +-- .../proof-of-sql/src/sql/proof/query_proof.rs | 9 ++- .../src/sql/proof/query_proof_test.rs | 23 +++----- .../sql/proof/verifiable_query_result_test.rs | 5 +- .../src/sql/proof_plans/empty_exec.rs | 5 +- .../src/sql/proof_plans/filter_exec.rs | 8 +-- .../src/sql/proof_plans/filter_exec_test.rs | 56 +++++++++++-------- .../filter_exec_test_dishonest_prover.rs | 8 +-- .../src/sql/proof_plans/group_by_exec.rs | 8 +-- .../src/sql/proof_plans/projection_exec.rs | 5 +- .../sql/proof_plans/projection_exec_test.rs | 45 +++++++++------ .../src/sql/proof_plans/table_exec.rs | 5 +- 12 files changed, 96 insertions(+), 89 deletions(-) diff --git a/crates/proof-of-sql/src/sql/proof/proof_plan.rs b/crates/proof-of-sql/src/sql/proof/proof_plan.rs index e86bdf943..e3ca276a0 100644 --- a/crates/proof-of-sql/src/sql/proof/proof_plan.rs +++ b/crates/proof-of-sql/src/sql/proof/proof_plan.rs @@ -36,16 +36,14 @@ pub trait ProofPlan: Debug + Send + Sync + ProverEvaluate { #[enum_dispatch::enum_dispatch(DynProofPlan)] pub trait ProverEvaluate { - /// Evaluate the query and return the result. - fn result_evaluate<'a, S: Scalar>( + /// Evaluate the query, modify `FirstRoundBuilder` and return the result. + fn first_round_evaluate<'a, S: Scalar>( &self, + builder: &mut FirstRoundBuilder, alloc: &'a Bump, table_map: &IndexMap>, ) -> (Table<'a, S>, Vec); - /// Evaluate the query and modify `FirstRoundBuilder` to form the query's proof. - fn first_round_evaluate(&self, builder: &mut FirstRoundBuilder); - /// Evaluate the query and modify `FinalRoundBuilder` to store an intermediate representation /// of the query result and track all the components needed to form the query's proof. /// diff --git a/crates/proof-of-sql/src/sql/proof/query_proof.rs b/crates/proof-of-sql/src/sql/proof/query_proof.rs index 19cb80573..99856c694 100644 --- a/crates/proof-of-sql/src/sql/proof/query_proof.rs +++ b/crates/proof-of-sql/src/sql/proof/query_proof.rs @@ -92,13 +92,12 @@ impl QueryProof { }) .collect(); - // Evaluate query result - let (query_result, one_evaluation_lengths) = expr.result_evaluate(&alloc, &table_map); + // Prover First Round: Evaluate the query && get the right number of post result challenges + let mut first_round_builder = FirstRoundBuilder::new(); + let (query_result, one_evaluation_lengths) = + expr.first_round_evaluate(&mut first_round_builder, &alloc, &table_map); let provable_result = query_result.into(); - // Prover First Round - let mut first_round_builder = FirstRoundBuilder::new(); - expr.first_round_evaluate(&mut first_round_builder); let range_length = one_evaluation_lengths .iter() .copied() diff --git a/crates/proof-of-sql/src/sql/proof/query_proof_test.rs b/crates/proof-of-sql/src/sql/proof/query_proof_test.rs index 40a1a0eb5..22d8c3d4a 100644 --- a/crates/proof-of-sql/src/sql/proof/query_proof_test.rs +++ b/crates/proof-of-sql/src/sql/proof/query_proof_test.rs @@ -42,8 +42,9 @@ impl Default for TrivialTestProofPlan { } } impl ProverEvaluate for TrivialTestProofPlan { - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + _builder: &mut FirstRoundBuilder, alloc: &'a Bump, _table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { @@ -54,8 +55,6 @@ impl ProverEvaluate for TrivialTestProofPlan { ) } - fn first_round_evaluate(&self, _builder: &mut FirstRoundBuilder) {} - fn final_round_evaluate<'a, S: Scalar>( &self, builder: &mut FinalRoundBuilder<'a, S>, @@ -225,16 +224,15 @@ impl Default for SquareTestProofPlan { } } impl ProverEvaluate for SquareTestProofPlan { - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + _builder: &mut FirstRoundBuilder, alloc: &'a Bump, _table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { (table([borrowed_bigint("a1", self.res, alloc)]), vec![2]) } - fn first_round_evaluate(&self, _builder: &mut FirstRoundBuilder) {} - fn final_round_evaluate<'a, S: Scalar>( &self, builder: &mut FinalRoundBuilder<'a, S>, @@ -409,16 +407,15 @@ impl Default for DoubleSquareTestProofPlan { } } impl ProverEvaluate for DoubleSquareTestProofPlan { - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + _builder: &mut FirstRoundBuilder, alloc: &'a Bump, _table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { (table([borrowed_bigint("a1", self.res, alloc)]), vec![2]) } - fn first_round_evaluate(&self, _builder: &mut FirstRoundBuilder) {} - fn final_round_evaluate<'a, S: Scalar>( &self, builder: &mut FinalRoundBuilder<'a, S>, @@ -623,16 +620,14 @@ fn verify_fails_the_result_doesnt_satisfy_an_intermediate_equation() { #[derive(Debug, Serialize)] struct ChallengeTestProofPlan {} impl ProverEvaluate for ChallengeTestProofPlan { - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + builder: &mut FirstRoundBuilder, alloc: &'a Bump, _table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { - (table([borrowed_bigint("a1", [9, 25], alloc)]), vec![2]) - } - - fn first_round_evaluate(&self, builder: &mut FirstRoundBuilder) { builder.request_post_result_challenges(2); + (table([borrowed_bigint("a1", [9, 25], alloc)]), vec![2]) } fn final_round_evaluate<'a, S: Scalar>( diff --git a/crates/proof-of-sql/src/sql/proof/verifiable_query_result_test.rs b/crates/proof-of-sql/src/sql/proof/verifiable_query_result_test.rs index 7c01fbee2..cba0097fe 100644 --- a/crates/proof-of-sql/src/sql/proof/verifiable_query_result_test.rs +++ b/crates/proof-of-sql/src/sql/proof/verifiable_query_result_test.rs @@ -26,8 +26,9 @@ pub(super) struct EmptyTestQueryExpr { pub(super) columns: usize, } impl ProverEvaluate for EmptyTestQueryExpr { - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + _builder: &mut FirstRoundBuilder, alloc: &'a Bump, _table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { @@ -40,7 +41,7 @@ impl ProverEvaluate for EmptyTestQueryExpr { vec![self.length], ) } - fn first_round_evaluate(&self, _builder: &mut FirstRoundBuilder) {} + fn final_round_evaluate<'a, S: Scalar>( &self, builder: &mut FinalRoundBuilder<'a, S>, diff --git a/crates/proof-of-sql/src/sql/proof_plans/empty_exec.rs b/crates/proof-of-sql/src/sql/proof_plans/empty_exec.rs index 157b8f409..3d557f9e3 100644 --- a/crates/proof-of-sql/src/sql/proof_plans/empty_exec.rs +++ b/crates/proof-of-sql/src/sql/proof_plans/empty_exec.rs @@ -69,8 +69,9 @@ impl ProofPlan for EmptyExec { impl ProverEvaluate for EmptyExec { #[tracing::instrument(name = "EmptyExec::result_evaluate", level = "debug", skip_all)] - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + _builder: &mut FirstRoundBuilder, _alloc: &'a Bump, _table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { @@ -82,8 +83,6 @@ impl ProverEvaluate for EmptyExec { ) } - fn first_round_evaluate(&self, _builder: &mut FirstRoundBuilder) {} - #[tracing::instrument(name = "EmptyExec::final_round_evaluate", level = "debug", skip_all)] #[allow(unused_variables)] fn final_round_evaluate<'a, S: Scalar>( diff --git a/crates/proof-of-sql/src/sql/proof_plans/filter_exec.rs b/crates/proof-of-sql/src/sql/proof_plans/filter_exec.rs index 4eba6c173..326381e10 100644 --- a/crates/proof-of-sql/src/sql/proof_plans/filter_exec.rs +++ b/crates/proof-of-sql/src/sql/proof_plans/filter_exec.rs @@ -154,8 +154,9 @@ pub type FilterExec = OstensibleFilterExec; impl ProverEvaluate for FilterExec { #[tracing::instrument(name = "FilterExec::result_evaluate", level = "debug", skip_all)] - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + builder: &mut FirstRoundBuilder, alloc: &'a Bump, table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { @@ -186,11 +187,8 @@ impl ProverEvaluate for FilterExec { TableOptions::new(Some(output_length)), ) .expect("Failed to create table from iterator"); - (res, vec![output_length]) - } - - fn first_round_evaluate(&self, builder: &mut FirstRoundBuilder) { builder.request_post_result_challenges(2); + (res, vec![output_length]) } #[tracing::instrument(name = "FilterExec::final_round_evaluate", level = "debug", skip_all)] diff --git a/crates/proof-of-sql/src/sql/proof_plans/filter_exec_test.rs b/crates/proof-of-sql/src/sql/proof_plans/filter_exec_test.rs index 94bc43401..5d7118b69 100644 --- a/crates/proof-of-sql/src/sql/proof_plans/filter_exec_test.rs +++ b/crates/proof-of-sql/src/sql/proof_plans/filter_exec_test.rs @@ -12,8 +12,8 @@ use crate::{ }, sql::{ proof::{ - exercise_verification, ProofPlan, ProvableQueryResult, ProverEvaluate, - VerifiableQueryResult, + exercise_verification, FirstRoundBuilder, ProofPlan, ProvableQueryResult, + ProverEvaluate, VerifiableQueryResult, }, proof_exprs::{test_utility::*, ColumnExpr, DynProofExpr, LiteralExpr, TableExpr}, }, @@ -177,7 +177,7 @@ fn we_can_prove_and_get_the_correct_result_from_a_basic_filter() { } #[test] -fn we_can_get_an_empty_result_from_a_basic_filter_on_an_empty_table_using_result_evaluate() { +fn we_can_get_an_empty_result_from_a_basic_filter_on_an_empty_table_using_first_round_evaluate() { let alloc = Bump::new(); let data = table([ borrowed_bigint("a", [0; 0], &alloc), @@ -207,10 +207,13 @@ fn we_can_get_an_empty_result_from_a_basic_filter_on_an_empty_table_using_result ColumnType::Decimal75(Precision::new(75).unwrap(), 0), ), ]; - let res: OwnedTable = - ProvableQueryResult::from(expr.result_evaluate(&alloc, &table_map).0) - .to_owned_table(fields) - .unwrap(); + let first_round_builder = &mut FirstRoundBuilder::new(); + let res: OwnedTable = ProvableQueryResult::from( + expr.first_round_evaluate(first_round_builder, &alloc, &table_map) + .0, + ) + .to_owned_table(fields) + .unwrap(); let expected: OwnedTable = owned_table([ bigint("b", [0; 0]), int128("c", [0; 0]), @@ -222,7 +225,7 @@ fn we_can_get_an_empty_result_from_a_basic_filter_on_an_empty_table_using_result } #[test] -fn we_can_get_an_empty_result_from_a_basic_filter_using_result_evaluate() { +fn we_can_get_an_empty_result_from_a_basic_filter_using_first_round_evaluate() { let alloc = Bump::new(); let data = table([ borrowed_bigint("a", [1, 4, 5, 2, 5], &alloc), @@ -252,10 +255,13 @@ fn we_can_get_an_empty_result_from_a_basic_filter_using_result_evaluate() { ColumnType::Decimal75(Precision::new(1).unwrap(), 0), ), ]; - let res: OwnedTable = - ProvableQueryResult::from(expr.result_evaluate(&alloc, &table_map).0) - .to_owned_table(fields) - .unwrap(); + let first_round_builder = &mut FirstRoundBuilder::new(); + let res: OwnedTable = ProvableQueryResult::from( + expr.first_round_evaluate(first_round_builder, &alloc, &table_map) + .0, + ) + .to_owned_table(fields) + .unwrap(); let expected: OwnedTable = owned_table([ bigint("b", [0; 0]), int128("c", [0; 0]), @@ -267,7 +273,7 @@ fn we_can_get_an_empty_result_from_a_basic_filter_using_result_evaluate() { } #[test] -fn we_can_get_no_columns_from_a_basic_filter_with_no_selected_columns_using_result_evaluate() { +fn we_can_get_no_columns_from_a_basic_filter_with_no_selected_columns_using_first_round_evaluate() { let alloc = Bump::new(); let data = table([ borrowed_bigint("a", [1, 4, 5, 2, 5], &alloc), @@ -285,16 +291,19 @@ fn we_can_get_no_columns_from_a_basic_filter_with_no_selected_columns_using_resu let where_clause: DynProofExpr = equal(column(t, "a", &accessor), const_int128(5)); let expr = filter(cols_expr_plan(t, &[], &accessor), tab(t), where_clause); let fields = &[]; - let res: OwnedTable = - ProvableQueryResult::from(expr.result_evaluate(&alloc, &table_map).0) - .to_owned_table(fields) - .unwrap(); + let first_round_builder = &mut FirstRoundBuilder::new(); + let res: OwnedTable = ProvableQueryResult::from( + expr.first_round_evaluate(first_round_builder, &alloc, &table_map) + .0, + ) + .to_owned_table(fields) + .unwrap(); let expected = OwnedTable::try_new(IndexMap::default()).unwrap(); assert_eq!(res, expected); } #[test] -fn we_can_get_the_correct_result_from_a_basic_filter_using_result_evaluate() { +fn we_can_get_the_correct_result_from_a_basic_filter_using_first_round_evaluate() { let alloc = Bump::new(); let data = table([ borrowed_bigint("a", [1, 4, 5, 2, 5], &alloc), @@ -324,10 +333,13 @@ fn we_can_get_the_correct_result_from_a_basic_filter_using_result_evaluate() { ColumnType::Decimal75(Precision::new(1).unwrap(), 0), ), ]; - let res: OwnedTable = - ProvableQueryResult::from(expr.result_evaluate(&alloc, &table_map).0) - .to_owned_table(fields) - .unwrap(); + let first_round_builder = &mut FirstRoundBuilder::new(); + let res: OwnedTable = ProvableQueryResult::from( + expr.first_round_evaluate(first_round_builder, &alloc, &table_map) + .0, + ) + .to_owned_table(fields) + .unwrap(); let expected: OwnedTable = owned_table([ bigint("b", [3, 5]), int128("c", [3, 5]), diff --git a/crates/proof-of-sql/src/sql/proof_plans/filter_exec_test_dishonest_prover.rs b/crates/proof-of-sql/src/sql/proof_plans/filter_exec_test_dishonest_prover.rs index 149a2064d..fc1b15de1 100644 --- a/crates/proof-of-sql/src/sql/proof_plans/filter_exec_test_dishonest_prover.rs +++ b/crates/proof-of-sql/src/sql/proof_plans/filter_exec_test_dishonest_prover.rs @@ -34,8 +34,9 @@ impl ProverEvaluate for DishonestFilterExec { level = "debug", skip_all )] - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + builder: &mut FirstRoundBuilder, alloc: &'a Bump, table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { @@ -65,11 +66,8 @@ impl ProverEvaluate for DishonestFilterExec { TableOptions::new(Some(output_length)), ) .expect("Failed to create table from iterator"); - (res, vec![output_length]) - } - - fn first_round_evaluate(&self, builder: &mut FirstRoundBuilder) { builder.request_post_result_challenges(2); + (res, vec![output_length]) } #[tracing::instrument( diff --git a/crates/proof-of-sql/src/sql/proof_plans/group_by_exec.rs b/crates/proof-of-sql/src/sql/proof_plans/group_by_exec.rs index 800c1ad3e..f21d4f418 100644 --- a/crates/proof-of-sql/src/sql/proof_plans/group_by_exec.rs +++ b/crates/proof-of-sql/src/sql/proof_plans/group_by_exec.rs @@ -208,8 +208,9 @@ impl ProofPlan for GroupByExec { impl ProverEvaluate for GroupByExec { #[tracing::instrument(name = "GroupByExec::result_evaluate", level = "debug", skip_all)] - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + builder: &mut FirstRoundBuilder, alloc: &'a Bump, table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { @@ -255,11 +256,8 @@ impl ProverEvaluate for GroupByExec { ), ) .expect("Failed to create table from column references"); - (res, vec![count_column.len()]) - } - - fn first_round_evaluate(&self, builder: &mut FirstRoundBuilder) { builder.request_post_result_challenges(2); + (res, vec![count_column.len()]) } #[tracing::instrument(name = "GroupByExec::final_round_evaluate", level = "debug", skip_all)] diff --git a/crates/proof-of-sql/src/sql/proof_plans/projection_exec.rs b/crates/proof-of-sql/src/sql/proof_plans/projection_exec.rs index 64cdf9608..074f7abec 100644 --- a/crates/proof-of-sql/src/sql/proof_plans/projection_exec.rs +++ b/crates/proof-of-sql/src/sql/proof_plans/projection_exec.rs @@ -97,8 +97,9 @@ impl ProofPlan for ProjectionExec { impl ProverEvaluate for ProjectionExec { #[tracing::instrument(name = "ProjectionExec::result_evaluate", level = "debug", skip_all)] - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + _builder: &mut FirstRoundBuilder, alloc: &'a Bump, table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { @@ -120,8 +121,6 @@ impl ProverEvaluate for ProjectionExec { ) } - fn first_round_evaluate(&self, _builder: &mut FirstRoundBuilder) {} - #[tracing::instrument( name = "ProjectionExec::final_round_evaluate", level = "debug", diff --git a/crates/proof-of-sql/src/sql/proof_plans/projection_exec_test.rs b/crates/proof-of-sql/src/sql/proof_plans/projection_exec_test.rs index b1b5a503b..597327db1 100644 --- a/crates/proof-of-sql/src/sql/proof_plans/projection_exec_test.rs +++ b/crates/proof-of-sql/src/sql/proof_plans/projection_exec_test.rs @@ -11,8 +11,8 @@ use crate::{ }, sql::{ proof::{ - exercise_verification, ProofPlan, ProvableQueryResult, ProverEvaluate, - VerifiableQueryResult, + exercise_verification, FirstRoundBuilder, ProofPlan, ProvableQueryResult, + ProverEvaluate, VerifiableQueryResult, }, proof_exprs::{test_utility::*, ColumnExpr, DynProofExpr, TableExpr}, }, @@ -154,7 +154,8 @@ fn we_can_prove_and_get_the_correct_result_from_a_nontrivial_projection() { } #[test] -fn we_can_get_an_empty_result_from_a_basic_projection_on_an_empty_table_using_result_evaluate() { +fn we_can_get_an_empty_result_from_a_basic_projection_on_an_empty_table_using_first_round_evaluate() +{ let alloc = Bump::new(); let data = table([ borrowed_bigint("a", [0; 0], &alloc), @@ -180,10 +181,13 @@ fn we_can_get_an_empty_result_from_a_basic_projection_on_an_empty_table_using_re ColumnType::Decimal75(Precision::new(75).unwrap(), 0), ), ]; - let res: OwnedTable = - ProvableQueryResult::from(expr.result_evaluate(&alloc, &table_map).0) - .to_owned_table(fields) - .unwrap(); + let first_round_builder = &mut FirstRoundBuilder::new(); + let res: OwnedTable = ProvableQueryResult::from( + expr.first_round_evaluate(first_round_builder, &alloc, &table_map) + .0, + ) + .to_owned_table(fields) + .unwrap(); let expected: OwnedTable = owned_table([ bigint("b", [0; 0]), int128("c", [0; 0]), @@ -195,7 +199,8 @@ fn we_can_get_an_empty_result_from_a_basic_projection_on_an_empty_table_using_re } #[test] -fn we_can_get_no_columns_from_a_basic_projection_with_no_selected_columns_using_result_evaluate() { +fn we_can_get_no_columns_from_a_basic_projection_with_no_selected_columns_using_first_round_evaluate( +) { let alloc = Bump::new(); let data = table([ borrowed_bigint("a", [1, 4, 5, 2, 5], &alloc), @@ -212,16 +217,19 @@ fn we_can_get_no_columns_from_a_basic_projection_with_no_selected_columns_using_ accessor.add_table(t, data, 0); let expr: DynProofPlan = projection(cols_expr_plan(t, &[], &accessor), tab(t)); let fields = &[]; - let res: OwnedTable = - ProvableQueryResult::from(expr.result_evaluate(&alloc, &table_map).0) - .to_owned_table(fields) - .unwrap(); + let first_round_builder = &mut FirstRoundBuilder::new(); + let res: OwnedTable = ProvableQueryResult::from( + expr.first_round_evaluate(first_round_builder, &alloc, &table_map) + .0, + ) + .to_owned_table(fields) + .unwrap(); let expected = OwnedTable::try_new(IndexMap::default()).unwrap(); assert_eq!(res, expected); } #[test] -fn we_can_get_the_correct_result_from_a_basic_projection_using_result_evaluate() { +fn we_can_get_the_correct_result_from_a_basic_projection_using_first_round_evaluate() { let alloc = Bump::new(); let data = table([ borrowed_bigint("a", [1, 4, 5, 2, 5], &alloc), @@ -257,10 +265,13 @@ fn we_can_get_the_correct_result_from_a_basic_projection_using_result_evaluate() ColumnType::Decimal75(Precision::new(1).unwrap(), 0), ), ]; - let res: OwnedTable = - ProvableQueryResult::from(expr.result_evaluate(&alloc, &table_map).0) - .to_owned_table(fields) - .unwrap(); + let first_round_builder = &mut FirstRoundBuilder::new(); + let res: OwnedTable = ProvableQueryResult::from( + expr.first_round_evaluate(first_round_builder, &alloc, &table_map) + .0, + ) + .to_owned_table(fields) + .unwrap(); let expected: OwnedTable = owned_table([ bigint("b", [2, 3, 4, 5, 6]), int128("prod", [1, 4, 9, 16, 25]), diff --git a/crates/proof-of-sql/src/sql/proof_plans/table_exec.rs b/crates/proof-of-sql/src/sql/proof_plans/table_exec.rs index db1fdda7b..2ae3dabd6 100644 --- a/crates/proof-of-sql/src/sql/proof_plans/table_exec.rs +++ b/crates/proof-of-sql/src/sql/proof_plans/table_exec.rs @@ -78,8 +78,9 @@ impl ProofPlan for TableExec { impl ProverEvaluate for TableExec { #[tracing::instrument(name = "TableExec::result_evaluate", level = "debug", skip_all)] - fn result_evaluate<'a, S: Scalar>( + fn first_round_evaluate<'a, S: Scalar>( &self, + _builder: &mut FirstRoundBuilder, _alloc: &'a Bump, table_map: &IndexMap>, ) -> (Table<'a, S>, Vec) { @@ -92,8 +93,6 @@ impl ProverEvaluate for TableExec { ) } - fn first_round_evaluate(&self, _builder: &mut FirstRoundBuilder) {} - #[tracing::instrument(name = "TableExec::final_round_evaluate", level = "debug", skip_all)] #[allow(unused_variables)] fn final_round_evaluate<'a, S: Scalar>(