From 6ca56fe86f47758076c1e3d727af6376189d2ad2 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 8 Apr 2024 11:24:28 +0000 Subject: [PATCH 1/6] feat: circuit builder does not need to compute inverses, prover does so --- bberg/src/circuit_builder.rs | 9 ++++++--- bberg/src/lookup_builder.rs | 2 +- bberg/src/vm_builder.rs | 19 +++++++++++++------ 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/bberg/src/circuit_builder.rs b/bberg/src/circuit_builder.rs index 77e15d2e51..04c6205d6e 100644 --- a/bberg/src/circuit_builder.rs +++ b/bberg/src/circuit_builder.rs @@ -10,8 +10,9 @@ pub trait CircuitBuilder { name: &str, relations: &[String], permutations: &[String], - fixed: &[String], - shifted: &[String], + all_cols_without_inverses: &[String], + all_cols: &[String], + to_be_shifted: &[String], all_cols_with_shifts: &[String], ); } @@ -62,6 +63,7 @@ impl CircuitBuilder for BBFiles { name: &str, relations: &[String], permutations: &[String], + all_cols_without_inverses: &[String], all_cols: &[String], to_be_shifted: &[String], all_cols_with_shifts: &[String], @@ -97,7 +99,8 @@ impl CircuitBuilder for BBFiles { }; // Apply transformations - let compute_polys_assignemnt = map_with_newline(all_cols, compute_polys_transformation); + // TODO: check if all_cols can now be removed + let compute_polys_assignemnt = map_with_newline(all_cols_without_inverses, compute_polys_transformation); let all_poly_shifts = map_with_newline(to_be_shifted, all_polys_transformation); let check_circuit_for_each_relation = map_with_newline(relations, check_circuit_transformation); diff --git a/bberg/src/lookup_builder.rs b/bberg/src/lookup_builder.rs index e70b864efd..dc3a23d0b7 100644 --- a/bberg/src/lookup_builder.rs +++ b/bberg/src/lookup_builder.rs @@ -188,7 +188,7 @@ fn create_lookup_settings_file(lookup: &Lookup) -> String { let lookup_tuple_size = columns_per_set; // NOTE: hardcoded until optimizations required - let inverse_degree = 2; + let inverse_degree = 4; let read_term_degree = 0; let write_term_degree = 0; let read_term_types = "{0}"; diff --git a/bberg/src/vm_builder.rs b/bberg/src/vm_builder.rs index ced22d7b4a..d6fa55d586 100644 --- a/bberg/src/vm_builder.rs +++ b/bberg/src/vm_builder.rs @@ -29,7 +29,9 @@ struct ColumnGroups { fixed: Vec, /// witness or commit columns in pil -> will be found in proof witness: Vec, - /// fixed + witness columns + /// fixed + witness columns without lookup inverses + all_cols_without_inverses: Vec, + /// fixed + witness columns with lookup inverses all_cols: Vec, /// Columns that will not be shifted unshifted: Vec, @@ -86,6 +88,7 @@ pub(crate) fn analyzed_to_cpp( fixed, witness, all_cols, + all_cols_without_inverses, unshifted: _unshifted, to_be_shifted, shifted, @@ -100,6 +103,7 @@ pub(crate) fn analyzed_to_cpp( file_name, &relations, &inverses, + &all_cols_without_inverses, &all_cols, &to_be_shifted, &all_cols_with_shifts, @@ -161,22 +165,25 @@ fn get_all_col_names( let witness_names = collect_col(witness, sanitize); let inverses = flatten(&[perm_inverses, lookup_inverses]); - let witness_names = flatten(&[witness_names, inverses.clone(), lookup_counts]); + let witness_names_without_inverses = flatten(&[witness_names.clone(), lookup_counts.clone()]); + let witness_names_with_inverses = flatten(&[witness_names, inverses.clone(), lookup_counts]); // Group columns by properties let shifted = transform_map(to_be_shifted, append_shift); - let all_cols: Vec = flatten(&[fixed_names.clone(), witness_names.clone()]); - let unshifted: Vec = flatten(&[fixed_names.clone(), witness_names.clone()]) + let all_cols_without_inverses : Vec = flatten(&[fixed_names.clone(), witness_names_without_inverses.clone()]); + let all_cols: Vec = flatten(&[fixed_names.clone(), witness_names_with_inverses.clone()]); + let unshifted: Vec = flatten(&[fixed_names.clone(), witness_names_with_inverses.clone()]) .into_iter() .filter(|name| !shifted.contains(name)) .collect(); let all_cols_with_shifts: Vec = - flatten(&[fixed_names.clone(), witness_names.clone(), shifted.clone()]); + flatten(&[fixed_names.clone(), witness_names_with_inverses.clone(), shifted.clone()]); ColumnGroups { fixed: fixed_names, - witness: witness_names, + witness: witness_names_with_inverses, + all_cols_without_inverses, all_cols, unshifted, to_be_shifted: to_be_shifted.to_vec(), From 71b9d941316e0583c8c5bcd9b5b3ce03c44f3f47 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 8 Apr 2024 18:23:01 +0000 Subject: [PATCH 2/6] fix: integration cleanup --- bberg/src/composer_builder.rs | 4 +- bberg/src/flavor_builder.rs | 99 ++++++++++++++++++++++++++++++----- bberg/src/prover_builder.rs | 85 ++++++++++++++++++++++++------ bberg/src/verifier_builder.rs | 14 ++++- bberg/src/vm_builder.rs | 25 +++++---- 5 files changed, 183 insertions(+), 44 deletions(-) diff --git a/bberg/src/composer_builder.rs b/bberg/src/composer_builder.rs index 26e0cdd57e..2cbd8576d1 100644 --- a/bberg/src/composer_builder.rs +++ b/bberg/src/composer_builder.rs @@ -40,7 +40,7 @@ void {name}Composer::compute_witness(CircuitConstructor& circuit) compute_witness(circuit_constructor); compute_commitment_key(circuit_constructor.get_circuit_subgroup_size()); - {name}Prover output_state(proving_key, commitment_key); + {name}Prover output_state(proving_key, proving_key->commitment_key); return output_state; }} @@ -167,7 +167,7 @@ class {name}Composer {{ void compute_commitment_key(size_t circuit_size) {{ - commitment_key = std::make_shared(circuit_size); + proving_key->commitment_key = std::make_shared(circuit_size); }}; }}; diff --git a/bberg/src/flavor_builder.rs b/bberg/src/flavor_builder.rs index c29178f38a..2c10a54230 100644 --- a/bberg/src/flavor_builder.rs +++ b/bberg/src/flavor_builder.rs @@ -1,7 +1,5 @@ use crate::{ - file_writer::BBFiles, - permutation_builder::{get_inverses_from_permutations, Permutation}, - utils::{get_relations_imports, map_with_newline, snake_case}, + file_writer::BBFiles, lookup_builder::{get_inverses_from_lookups, Lookup}, permutation_builder::{get_inverses_from_permutations, Permutation}, utils::{get_relations_imports, map_with_newline, snake_case} }; pub trait FlavorBuilder { @@ -11,6 +9,7 @@ pub trait FlavorBuilder { name: &str, relation_file_names: &[String], permutations: &[Permutation], + lookups: &[Lookup], fixed: &[String], witness: &[String], all_cols: &[String], @@ -27,6 +26,7 @@ impl FlavorBuilder for BBFiles { name: &str, relation_file_names: &[String], permutations: &[Permutation], + lookups: &[Lookup], fixed: &[String], witness: &[String], all_cols: &[String], @@ -35,7 +35,15 @@ impl FlavorBuilder for BBFiles { all_cols_and_shifts: &[String], ) { // TODO: move elsewhere and rename - let inverses = get_inverses_from_permutations(permutations); + let permutation_inverses = get_inverses_from_permutations(permutations); + let lookup_inverses = get_inverses_from_lookups(lookups); + + // Inverses from both permutations and lookups + let inverses: Vec = permutation_inverses + .iter() + .chain(lookup_inverses.iter()) + .map(|inv| inv.clone()) + .collect(); let first_poly = &witness[0]; let includes = flavor_includes(&snake_case(name), relation_file_names, &inverses); @@ -46,7 +54,7 @@ impl FlavorBuilder for BBFiles { // Top of file boilerplate let class_aliases = create_class_aliases(); let relation_definitions = - create_relation_definitions(name, relation_file_names, permutations); + create_relation_definitions(name, relation_file_names, permutations, lookups); let container_size_definitions = container_size_definitions(num_precomputed, num_witness, num_all); @@ -56,7 +64,7 @@ impl FlavorBuilder for BBFiles { let all_entities = create_all_entities(all_cols, to_be_shifted, shifted, all_cols_and_shifts); - let proving_and_verification_key = create_proving_and_verification_key(to_be_shifted); + let proving_and_verification_key = create_proving_and_verification_key(name, permutations, lookups,to_be_shifted); let polynomial_views = create_polynomial_views(first_poly); let commitment_labels_class = create_commitment_labels(all_cols); @@ -151,6 +159,7 @@ fn create_relations_tuple(master_name: &str, relation_file_names: &[String]) -> /// Creates comma separated relations tuple file /// TODO(md): maybe need the filename in here too if we scope these +/// TOOD: both this and below could maybe be removed as we are peeking the inverses into a list above fn create_permutations_tuple(permutations: &[Permutation]) -> String { permutations .iter() @@ -159,6 +168,15 @@ fn create_permutations_tuple(permutations: &[Permutation]) -> String { .join(", ") } +// TODO: could unify with above??? +fn create_lookups_tuple(lookups: &[Lookup]) -> String { + lookups + .iter() + .map(|lookup| format!("{}_relation", lookup.attribute.clone().unwrap())) + .collect::>() + .join(", ") +} + /// Create Class Aliases /// /// Contains boilerplate defining key characteristics of the flavor class @@ -191,16 +209,30 @@ fn create_relation_definitions( name: &str, relation_file_names: &[String], permutations: &[Permutation], + lookups: &[Lookup], ) -> String { // Relations tuple = ns::relation_name_0, ns::relation_name_1, ... ns::relation_name_n (comma speratated) let comma_sep_relations = create_relations_tuple(name, relation_file_names); let comma_sep_perms: String = create_permutations_tuple(permutations); + let comma_sep_lookups: String = create_lookups_tuple(lookups); + + + // TODO: clean below - do empty check + let mut grand_product_relations = String::new(); let mut all_relations = comma_sep_relations.to_string(); if !permutations.is_empty() { all_relations = all_relations + &format!(", {comma_sep_perms}"); + grand_product_relations = grand_product_relations + &format!("{comma_sep_perms}"); + } + + if !lookups.is_empty() { + all_relations = all_relations + &format!(", {comma_sep_lookups}"); + grand_product_relations = grand_product_relations.to_owned() + &format!(", {comma_sep_lookups}"); } format!(" + using GrandProductRelations = std::tuple<{grand_product_relations}>; + using Relations = std::tuple<{all_relations}>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -209,7 +241,7 @@ fn create_relation_definitions( // random polynomial e.g. For \\sum(x) [A(x) * B(x) + C(x)] * PowZeta(X), relation length = 2 and random relation // length = 3 static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = MAX_PARTIAL_RELATION_LENGTH + 1; - static constexpr size_t NUM_RELATIONS = std::tuple_size::value; + static constexpr size_t NUM_RELATIONS = std::tuple_size_v; template using ProtogalaxyTupleOfTuplesOfUnivariates = @@ -284,7 +316,6 @@ fn create_witness_entities(witness: &[String]) -> String { let pointer_view = create_flavor_members(witness); let wires = return_ref_vector("get_wires", witness); - let sorted_polys = return_ref_vector("get_sorted_polynomials", &[]); format!( " @@ -295,7 +326,6 @@ fn create_witness_entities(witness: &[String]) -> String { {pointer_view} {wires} - {sorted_polys} }}; " ) @@ -333,8 +363,9 @@ fn create_all_entities( ) } -fn create_proving_and_verification_key(to_be_shifted: &[String]) -> String { +fn create_proving_and_verification_key(flavor_name: &str, permutations: &[Permutation], lookups: &[Lookup], to_be_shifted: &[String]) -> String { let get_to_be_shifted = return_ref_vector("get_to_be_shifted", to_be_shifted); + let compute_logderivative_inverses = create_compute_logderivative_inverses(flavor_name, permutations, lookups); format!(" public: @@ -346,8 +377,7 @@ fn create_proving_and_verification_key(to_be_shifted: &[String]) -> String { {get_to_be_shifted} - // The plookup wires that store plookup read data. - std::array get_table_column_wires() {{ return {{}}; }}; + {compute_logderivative_inverses} }}; using VerificationKey = VerificationKey_, VerifierCommitmentKey>; @@ -377,6 +407,19 @@ fn create_polynomial_views(first_poly: &String) -> String { ProverPolynomials(ProverPolynomials&& o) noexcept = default; ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default; ~ProverPolynomials() = default; + + ProverPolynomials(ProvingKey& proving_key) + {{ + for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key.get_all())) {{ + ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(proving_key, key_poly)); + prover_poly = key_poly.share(); + }} + for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key.get_to_be_shifted())) {{ + ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(proving_key, key_poly) + \"_shift\")); + prover_poly = key_poly.shifted(); + }} + }} + [[nodiscard]] size_t get_polynomial_size() const {{ return {first_poly}.size(); }} /** * @brief Returns the evaluations of all prover polynomials at one point on the boolean hypercube, which @@ -419,6 +462,12 @@ fn create_polynomial_views(first_poly: &String) -> String { */ using ExtendedEdges = ProverUnivariates; + /** + * @brief A container for the witness commitments. + * + */ + using WitnessCommitments = WitnessEntities; + ") } @@ -452,7 +501,6 @@ fn create_commitment_labels(all_ents: &[String]) -> String { private: using Base = AllEntities; - public: CommitmentLabels() : AllEntities() {{ @@ -463,6 +511,31 @@ fn create_commitment_labels(all_ents: &[String]) -> String { ) } +// TODO: clean +fn create_compute_logderivative_inverses(flavor_name: &str, permutations: &[Permutation], lookups: &[Lookup]) -> String{ + // TODO: clean + let mut all_perm_and_lookups = Vec::new(); + all_perm_and_lookups.extend(permutations.iter().map(|perm| perm.attribute.clone().unwrap())); + all_perm_and_lookups.extend(lookups.iter().map(|lookup| lookup.attribute.clone().unwrap())); + + let compute_inverse_transformation = |lookup_name: &String| format!("bb::compute_logderivative_inverse<{flavor_name}Flavor, {lookup_name}_relation>(prover_polynomials, relation_parameters, this->circuit_size);"); + + let compute_inverses = map_with_newline(&all_perm_and_lookups, compute_inverse_transformation); + + format!( + " + void compute_logderivative_inverses(const RelationParameters& relation_parameters) + {{ + ProverPolynomials prover_polynomials = ProverPolynomials(*this); + + {compute_inverses} + }} + " + + ) + +} + fn create_key_dereference(fixed: &[String]) -> String { let deref_transformation = |name: &String| format!("{name} = verification_key->{name};"); diff --git a/bberg/src/prover_builder.rs b/bberg/src/prover_builder.rs index 71dbc35b8b..803b528ea2 100644 --- a/bberg/src/prover_builder.rs +++ b/bberg/src/prover_builder.rs @@ -1,10 +1,10 @@ use crate::file_writer::BBFiles; -use crate::utils::snake_case; +use crate::utils::{map_with_newline, snake_case}; pub trait ProverBuilder { - fn create_prover_cpp(&mut self, name: &str); - fn create_prover_hpp(&mut self, name: &str); + + fn create_prover_cpp(&mut self, name: &str, commitment_polys: &[String], lookup_names: &[String]); } impl ProverBuilder for BBFiles { @@ -31,6 +31,7 @@ impl ProverBuilder for BBFiles { void execute_preamble_round(); void execute_wire_commitments_round(); + void execute_log_derivative_inverse_round(); void execute_relation_check_rounds(); void execute_zeromorph_rounds(); @@ -49,6 +50,7 @@ impl ProverBuilder for BBFiles { ProverPolynomials prover_polynomials; CommitmentLabels commitment_labels; + typename Flavor::WitnessCommitments witness_commitments; Polynomial quotient_W; @@ -72,9 +74,16 @@ impl ProverBuilder for BBFiles { ); } - fn create_prover_cpp(&mut self, name: &str) { + /// Create the prover cpp file + /// + /// Committed polys are included as we manually unroll all commitments, as we do not commit to everything + /// TODO: could this be placed with another flavor method that returns the correct phases? + fn create_prover_cpp(&mut self, name: &str, commitment_polys: &[String], lookup_names: &[String]) { let include_str = includes_cpp(&snake_case(name)); + let polynomial_commitment_phase = create_commitments_phase(commitment_polys); + let log_derivative_inverse_phase = create_log_derivative_inverse_round(lookup_names); + let prover_cpp = format!(" {include_str} @@ -121,19 +130,21 @@ impl ProverBuilder for BBFiles { }} /** - * @brief Compute commitments to the first three wires + * @brief Compute commitments to all of the witness wires (apart from the logderivative inverse wires) * */ void {name}Prover::execute_wire_commitments_round() {{ - auto wire_polys = key->get_wires(); - auto labels = commitment_labels.get_wires(); - for (size_t idx = 0; idx < wire_polys.size(); ++idx) {{ - transcript->send_to_verifier(labels[idx], commitment_key->commit(wire_polys[idx])); - }} + + {polynomial_commitment_phase} + }} - + void {name}Prover::execute_log_derivative_inverse_round() + {{ + + {log_derivative_inverse_phase} + }} /** * @brief Run Sumcheck resulting in u = (u_1,...,u_d) challenges and all evaluations at u being calculated. @@ -187,13 +198,8 @@ impl ProverBuilder for BBFiles { // Compute wire commitments execute_wire_commitments_round(); - // TODO: not implemented for codegen just yet // Compute sorted list accumulator and commitment - // execute_log_derivative_commitments_round(); - - // Fiat-Shamir: bbeta & gamma - // Compute grand product(s) and commitments. - // execute_grand_product_computation_round(); + execute_log_derivative_inverse_round(); // Fiat-Shamir: alpha // Run sumcheck subprotocol. @@ -252,3 +258,48 @@ fn includes_cpp(name: &str) -> String { " ) } + +// TODO: label +fn commitment_transform(name: &String) -> String { + format!("witness_commitments.{name} = commitment_key->commit(key->{name});") +} + +fn send_to_verifier_transform(name: &String) -> String { + format!("transcript->send_to_verifier(commitment_labels.{name}, witness_commitments.{name});") +} + +fn create_commitments_phase(polys_to_commit_to: &[String]) -> String { + let all_commit_operations = map_with_newline(polys_to_commit_to, commitment_transform); + let send_to_verifier_operations = map_with_newline(polys_to_commit_to, send_to_verifier_transform); + + format!( + " + // Commit to all polynomials (apart from logderivative inverse polynomials, which are committed to in the later logderivative phase) + {all_commit_operations} + + // Send all commitments to the verifier + {send_to_verifier_operations} + " + ) +} + +fn create_log_derivative_inverse_round(lookup_operations: &[String]) -> String { + let all_commit_operations = map_with_newline(lookup_operations, commitment_transform); + let send_to_verifier_operations = map_with_newline(lookup_operations, send_to_verifier_transform); + + format!( + " + auto [beta, gamm] = transcript->template get_challenges(\"beta\", \"gamma\"); + relation_parameters.beta = beta; + relation_parameters.gamma = gamm; + + key->compute_logderivative_inverses(relation_parameters); + + // Commit to all logderivative inverse polynomials + {all_commit_operations} + + // Send all commitments to the verifier + {send_to_verifier_operations} + " + ) +} \ No newline at end of file diff --git a/bberg/src/verifier_builder.rs b/bberg/src/verifier_builder.rs index b23cfe6010..292a82cb23 100644 --- a/bberg/src/verifier_builder.rs +++ b/bberg/src/verifier_builder.rs @@ -4,13 +4,13 @@ use crate::{ }; pub trait VerifierBuilder { - fn create_verifier_cpp(&mut self, name: &str, witness: &[String]); + fn create_verifier_cpp(&mut self, name: &str, witness: &[String], inverses: &[String]); fn create_verifier_hpp(&mut self, name: &str); } impl VerifierBuilder for BBFiles { - fn create_verifier_cpp(&mut self, name: &str, witness: &[String]) { + fn create_verifier_cpp(&mut self, name: &str, witness: &[String], inverses: &[String]) { let include_str = includes_cpp(&snake_case(name)); let wire_transformation = |n: &String| { @@ -18,7 +18,10 @@ impl VerifierBuilder for BBFiles { "commitments.{n} = transcript->template receive_from_prover(commitment_labels.{n});" ) }; + // TODO: make sure the inverse commitments are not included let wire_commitments = map_with_newline(witness, wire_transformation); + let inverse_commitments = map_with_newline(inverses, wire_transformation); + let ver_cpp = format!(" {include_str} @@ -70,6 +73,13 @@ impl VerifierBuilder for BBFiles { // Get commitments to VM wires {wire_commitments} + + auto [beta, gamm] = transcript->template get_challenges(\"beta\", \"gamma\"); + relation_parameters.beta = beta; + relation_parameters.gamma = gamm; + + // Get commitments to inverses + {inverse_commitments} // Execute Sumcheck Verifier const size_t log_circuit_size = numeric::get_msb(circuit_size); diff --git a/bberg/src/vm_builder.rs b/bberg/src/vm_builder.rs index d6fa55d586..8a780c53ea 100644 --- a/bberg/src/vm_builder.rs +++ b/bberg/src/vm_builder.rs @@ -29,6 +29,8 @@ struct ColumnGroups { fixed: Vec, /// witness or commit columns in pil -> will be found in proof witness: Vec, + /// witness or commit columns in pil, with out the inverse columns + witnesses_without_inverses: Vec, /// fixed + witness columns without lookup inverses all_cols_without_inverses: Vec, /// fixed + witness columns with lookup inverses @@ -87,6 +89,7 @@ pub(crate) fn analyzed_to_cpp( let ColumnGroups { fixed, witness, + witnesses_without_inverses, all_cols, all_cols_without_inverses, unshifted: _unshifted, @@ -113,7 +116,8 @@ pub(crate) fn analyzed_to_cpp( bb_files.create_flavor_hpp( file_name, &relations, - &permutations, + &permutations, // TODO: could be replaced with strings? + &lookups, &fixed, &witness, &all_cols, @@ -127,11 +131,11 @@ pub(crate) fn analyzed_to_cpp( bb_files.create_composer_hpp(file_name); // ----------------------- Create the Verifier files ----------------------- - bb_files.create_verifier_cpp(file_name, &witness); + bb_files.create_verifier_cpp(file_name, &witnesses_without_inverses, &inverses); bb_files.create_verifier_hpp(file_name); // ----------------------- Create the Prover files ----------------------- - bb_files.create_prover_cpp(file_name); + bb_files.create_prover_cpp(file_name, &witnesses_without_inverses, &inverses); bb_files.create_prover_hpp(file_name); } @@ -165,25 +169,26 @@ fn get_all_col_names( let witness_names = collect_col(witness, sanitize); let inverses = flatten(&[perm_inverses, lookup_inverses]); - let witness_names_without_inverses = flatten(&[witness_names.clone(), lookup_counts.clone()]); - let witness_names_with_inverses = flatten(&[witness_names, inverses.clone(), lookup_counts]); + let witnesses_without_inverses = flatten(&[witness_names.clone(), lookup_counts.clone()]); + let witnesses_with_inverses = flatten(&[witness_names, inverses.clone(), lookup_counts]); // Group columns by properties let shifted = transform_map(to_be_shifted, append_shift); - let all_cols_without_inverses : Vec = flatten(&[fixed_names.clone(), witness_names_without_inverses.clone()]); - let all_cols: Vec = flatten(&[fixed_names.clone(), witness_names_with_inverses.clone()]); - let unshifted: Vec = flatten(&[fixed_names.clone(), witness_names_with_inverses.clone()]) + let all_cols_without_inverses : Vec = flatten(&[fixed_names.clone(), witnesses_without_inverses.clone()]); + let all_cols: Vec = flatten(&[fixed_names.clone(), witnesses_with_inverses.clone()]); + let unshifted: Vec = flatten(&[fixed_names.clone(), witnesses_with_inverses.clone()]) .into_iter() .filter(|name| !shifted.contains(name)) .collect(); let all_cols_with_shifts: Vec = - flatten(&[fixed_names.clone(), witness_names_with_inverses.clone(), shifted.clone()]); + flatten(&[fixed_names.clone(), witnesses_with_inverses.clone(), shifted.clone()]); ColumnGroups { fixed: fixed_names, - witness: witness_names_with_inverses, + witness: witnesses_with_inverses, all_cols_without_inverses, + witnesses_without_inverses, all_cols, unshifted, to_be_shifted: to_be_shifted.to_vec(), From 3b18e7479dd106244fe72d3b597c7faf4bd295a1 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 8 Apr 2024 18:26:20 +0000 Subject: [PATCH 3/6] chore: sweep --- bberg/src/circuit_builder.rs | 1 - bberg/src/flavor_builder.rs | 6 ------ bberg/src/prover_builder.rs | 8 ++++++-- 3 files changed, 6 insertions(+), 9 deletions(-) diff --git a/bberg/src/circuit_builder.rs b/bberg/src/circuit_builder.rs index 04c6205d6e..ec02ba988c 100644 --- a/bberg/src/circuit_builder.rs +++ b/bberg/src/circuit_builder.rs @@ -99,7 +99,6 @@ impl CircuitBuilder for BBFiles { }; // Apply transformations - // TODO: check if all_cols can now be removed let compute_polys_assignemnt = map_with_newline(all_cols_without_inverses, compute_polys_transformation); let all_poly_shifts = map_with_newline(to_be_shifted, all_polys_transformation); let check_circuit_for_each_relation = diff --git a/bberg/src/flavor_builder.rs b/bberg/src/flavor_builder.rs index 2c10a54230..1bb7c54c6d 100644 --- a/bberg/src/flavor_builder.rs +++ b/bberg/src/flavor_builder.rs @@ -159,7 +159,6 @@ fn create_relations_tuple(master_name: &str, relation_file_names: &[String]) -> /// Creates comma separated relations tuple file /// TODO(md): maybe need the filename in here too if we scope these -/// TOOD: both this and below could maybe be removed as we are peeking the inverses into a list above fn create_permutations_tuple(permutations: &[Permutation]) -> String { permutations .iter() @@ -168,7 +167,6 @@ fn create_permutations_tuple(permutations: &[Permutation]) -> String { .join(", ") } -// TODO: could unify with above??? fn create_lookups_tuple(lookups: &[Lookup]) -> String { lookups .iter() @@ -216,8 +214,6 @@ fn create_relation_definitions( let comma_sep_perms: String = create_permutations_tuple(permutations); let comma_sep_lookups: String = create_lookups_tuple(lookups); - - // TODO: clean below - do empty check let mut grand_product_relations = String::new(); let mut all_relations = comma_sep_relations.to_string(); if !permutations.is_empty() { @@ -511,9 +507,7 @@ fn create_commitment_labels(all_ents: &[String]) -> String { ) } -// TODO: clean fn create_compute_logderivative_inverses(flavor_name: &str, permutations: &[Permutation], lookups: &[Lookup]) -> String{ - // TODO: clean let mut all_perm_and_lookups = Vec::new(); all_perm_and_lookups.extend(permutations.iter().map(|perm| perm.attribute.clone().unwrap())); all_perm_and_lookups.extend(lookups.iter().map(|lookup| lookup.attribute.clone().unwrap())); diff --git a/bberg/src/prover_builder.rs b/bberg/src/prover_builder.rs index 803b528ea2..c15c1731c4 100644 --- a/bberg/src/prover_builder.rs +++ b/bberg/src/prover_builder.rs @@ -77,7 +77,6 @@ impl ProverBuilder for BBFiles { /// Create the prover cpp file /// /// Committed polys are included as we manually unroll all commitments, as we do not commit to everything - /// TODO: could this be placed with another flavor method that returns the correct phases? fn create_prover_cpp(&mut self, name: &str, commitment_polys: &[String], lookup_names: &[String]) { let include_str = includes_cpp(&snake_case(name)); @@ -259,11 +258,16 @@ fn includes_cpp(name: &str) -> String { ) } -// TODO: label +/// Commitment Transform +/// +/// Produces code to perform kzg commitment, then stores in the witness_commitments struct fn commitment_transform(name: &String) -> String { format!("witness_commitments.{name} = commitment_key->commit(key->{name});") } +/// Send to Verifier Transform +/// +/// Sends commitment produces in commitment_transform to the verifier fn send_to_verifier_transform(name: &String) -> String { format!("transcript->send_to_verifier(commitment_labels.{name}, witness_commitments.{name});") } From 9c91cd7f201e82de21f159876dedc579cfed0312 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 8 Apr 2024 18:28:38 +0000 Subject: [PATCH 4/6] chore: clippy and fmt --- bberg/src/circuit_builder.rs | 3 +- bberg/src/flavor_builder.rs | 53 +++++++++++++++++++++++++---------- bberg/src/prover_builder.rs | 30 ++++++++++++++------ bberg/src/verifier_builder.rs | 1 - bberg/src/vm_builder.rs | 10 +++++-- 5 files changed, 68 insertions(+), 29 deletions(-) diff --git a/bberg/src/circuit_builder.rs b/bberg/src/circuit_builder.rs index ec02ba988c..35eec1508b 100644 --- a/bberg/src/circuit_builder.rs +++ b/bberg/src/circuit_builder.rs @@ -99,7 +99,8 @@ impl CircuitBuilder for BBFiles { }; // Apply transformations - let compute_polys_assignemnt = map_with_newline(all_cols_without_inverses, compute_polys_transformation); + let compute_polys_assignemnt = + map_with_newline(all_cols_without_inverses, compute_polys_transformation); let all_poly_shifts = map_with_newline(to_be_shifted, all_polys_transformation); let check_circuit_for_each_relation = map_with_newline(relations, check_circuit_transformation); diff --git a/bberg/src/flavor_builder.rs b/bberg/src/flavor_builder.rs index 1bb7c54c6d..a78250cd39 100644 --- a/bberg/src/flavor_builder.rs +++ b/bberg/src/flavor_builder.rs @@ -1,5 +1,8 @@ use crate::{ - file_writer::BBFiles, lookup_builder::{get_inverses_from_lookups, Lookup}, permutation_builder::{get_inverses_from_permutations, Permutation}, utils::{get_relations_imports, map_with_newline, snake_case} + file_writer::BBFiles, + lookup_builder::{get_inverses_from_lookups, Lookup}, + permutation_builder::{get_inverses_from_permutations, Permutation}, + utils::{get_relations_imports, map_with_newline, snake_case}, }; pub trait FlavorBuilder { @@ -37,12 +40,12 @@ impl FlavorBuilder for BBFiles { // TODO: move elsewhere and rename let permutation_inverses = get_inverses_from_permutations(permutations); let lookup_inverses = get_inverses_from_lookups(lookups); - + // Inverses from both permutations and lookups let inverses: Vec = permutation_inverses .iter() .chain(lookup_inverses.iter()) - .map(|inv| inv.clone()) + .cloned() .collect(); let first_poly = &witness[0]; @@ -64,7 +67,8 @@ impl FlavorBuilder for BBFiles { let all_entities = create_all_entities(all_cols, to_be_shifted, shifted, all_cols_and_shifts); - let proving_and_verification_key = create_proving_and_verification_key(name, permutations, lookups,to_be_shifted); + let proving_and_verification_key = + create_proving_and_verification_key(name, permutations, lookups, to_be_shifted); let polynomial_views = create_polynomial_views(first_poly); let commitment_labels_class = create_commitment_labels(all_cols); @@ -213,17 +217,18 @@ fn create_relation_definitions( let comma_sep_relations = create_relations_tuple(name, relation_file_names); let comma_sep_perms: String = create_permutations_tuple(permutations); let comma_sep_lookups: String = create_lookups_tuple(lookups); - + let mut grand_product_relations = String::new(); let mut all_relations = comma_sep_relations.to_string(); if !permutations.is_empty() { all_relations = all_relations + &format!(", {comma_sep_perms}"); - grand_product_relations = grand_product_relations + &format!("{comma_sep_perms}"); + grand_product_relations = grand_product_relations + &comma_sep_perms.to_string(); } if !lookups.is_empty() { all_relations = all_relations + &format!(", {comma_sep_lookups}"); - grand_product_relations = grand_product_relations.to_owned() + &format!(", {comma_sep_lookups}"); + grand_product_relations = + grand_product_relations.to_owned() + &format!(", {comma_sep_lookups}"); } format!(" @@ -359,9 +364,15 @@ fn create_all_entities( ) } -fn create_proving_and_verification_key(flavor_name: &str, permutations: &[Permutation], lookups: &[Lookup], to_be_shifted: &[String]) -> String { +fn create_proving_and_verification_key( + flavor_name: &str, + permutations: &[Permutation], + lookups: &[Lookup], + to_be_shifted: &[String], +) -> String { let get_to_be_shifted = return_ref_vector("get_to_be_shifted", to_be_shifted); - let compute_logderivative_inverses = create_compute_logderivative_inverses(flavor_name, permutations, lookups); + let compute_logderivative_inverses = + create_compute_logderivative_inverses(flavor_name, permutations, lookups); format!(" public: @@ -507,12 +518,26 @@ fn create_commitment_labels(all_ents: &[String]) -> String { ) } -fn create_compute_logderivative_inverses(flavor_name: &str, permutations: &[Permutation], lookups: &[Lookup]) -> String{ +fn create_compute_logderivative_inverses( + flavor_name: &str, + permutations: &[Permutation], + lookups: &[Lookup], +) -> String { let mut all_perm_and_lookups = Vec::new(); - all_perm_and_lookups.extend(permutations.iter().map(|perm| perm.attribute.clone().unwrap())); - all_perm_and_lookups.extend(lookups.iter().map(|lookup| lookup.attribute.clone().unwrap())); + all_perm_and_lookups.extend( + permutations + .iter() + .map(|perm| perm.attribute.clone().unwrap()), + ); + all_perm_and_lookups.extend( + lookups + .iter() + .map(|lookup| lookup.attribute.clone().unwrap()), + ); - let compute_inverse_transformation = |lookup_name: &String| format!("bb::compute_logderivative_inverse<{flavor_name}Flavor, {lookup_name}_relation>(prover_polynomials, relation_parameters, this->circuit_size);"); + let compute_inverse_transformation = |lookup_name: &String| { + format!("bb::compute_logderivative_inverse<{flavor_name}Flavor, {lookup_name}_relation>(prover_polynomials, relation_parameters, this->circuit_size);") + }; let compute_inverses = map_with_newline(&all_perm_and_lookups, compute_inverse_transformation); @@ -525,9 +550,7 @@ fn create_compute_logderivative_inverses(flavor_name: &str, permutations: &[Perm {compute_inverses} }} " - ) - } fn create_key_dereference(fixed: &[String]) -> String { diff --git a/bberg/src/prover_builder.rs b/bberg/src/prover_builder.rs index c15c1731c4..b7a313e2d3 100644 --- a/bberg/src/prover_builder.rs +++ b/bberg/src/prover_builder.rs @@ -4,7 +4,12 @@ use crate::utils::{map_with_newline, snake_case}; pub trait ProverBuilder { fn create_prover_hpp(&mut self, name: &str); - fn create_prover_cpp(&mut self, name: &str, commitment_polys: &[String], lookup_names: &[String]); + fn create_prover_cpp( + &mut self, + name: &str, + commitment_polys: &[String], + lookup_names: &[String], + ); } impl ProverBuilder for BBFiles { @@ -75,9 +80,14 @@ impl ProverBuilder for BBFiles { } /// Create the prover cpp file - /// + /// /// Committed polys are included as we manually unroll all commitments, as we do not commit to everything - fn create_prover_cpp(&mut self, name: &str, commitment_polys: &[String], lookup_names: &[String]) { + fn create_prover_cpp( + &mut self, + name: &str, + commitment_polys: &[String], + lookup_names: &[String], + ) { let include_str = includes_cpp(&snake_case(name)); let polynomial_commitment_phase = create_commitments_phase(commitment_polys); @@ -259,14 +269,14 @@ fn includes_cpp(name: &str) -> String { } /// Commitment Transform -/// +/// /// Produces code to perform kzg commitment, then stores in the witness_commitments struct fn commitment_transform(name: &String) -> String { format!("witness_commitments.{name} = commitment_key->commit(key->{name});") -} +} /// Send to Verifier Transform -/// +/// /// Sends commitment produces in commitment_transform to the verifier fn send_to_verifier_transform(name: &String) -> String { format!("transcript->send_to_verifier(commitment_labels.{name}, witness_commitments.{name});") @@ -274,7 +284,8 @@ fn send_to_verifier_transform(name: &String) -> String { fn create_commitments_phase(polys_to_commit_to: &[String]) -> String { let all_commit_operations = map_with_newline(polys_to_commit_to, commitment_transform); - let send_to_verifier_operations = map_with_newline(polys_to_commit_to, send_to_verifier_transform); + let send_to_verifier_operations = + map_with_newline(polys_to_commit_to, send_to_verifier_transform); format!( " @@ -289,7 +300,8 @@ fn create_commitments_phase(polys_to_commit_to: &[String]) -> String { fn create_log_derivative_inverse_round(lookup_operations: &[String]) -> String { let all_commit_operations = map_with_newline(lookup_operations, commitment_transform); - let send_to_verifier_operations = map_with_newline(lookup_operations, send_to_verifier_transform); + let send_to_verifier_operations = + map_with_newline(lookup_operations, send_to_verifier_transform); format!( " @@ -306,4 +318,4 @@ fn create_log_derivative_inverse_round(lookup_operations: &[String]) -> String { {send_to_verifier_operations} " ) -} \ No newline at end of file +} diff --git a/bberg/src/verifier_builder.rs b/bberg/src/verifier_builder.rs index 292a82cb23..c648d55052 100644 --- a/bberg/src/verifier_builder.rs +++ b/bberg/src/verifier_builder.rs @@ -21,7 +21,6 @@ impl VerifierBuilder for BBFiles { // TODO: make sure the inverse commitments are not included let wire_commitments = map_with_newline(witness, wire_transformation); let inverse_commitments = map_with_newline(inverses, wire_transformation); - let ver_cpp = format!(" {include_str} diff --git a/bberg/src/vm_builder.rs b/bberg/src/vm_builder.rs index 8a780c53ea..1bdb9e93e0 100644 --- a/bberg/src/vm_builder.rs +++ b/bberg/src/vm_builder.rs @@ -174,15 +174,19 @@ fn get_all_col_names( // Group columns by properties let shifted = transform_map(to_be_shifted, append_shift); - let all_cols_without_inverses : Vec = flatten(&[fixed_names.clone(), witnesses_without_inverses.clone()]); + let all_cols_without_inverses: Vec = + flatten(&[fixed_names.clone(), witnesses_without_inverses.clone()]); let all_cols: Vec = flatten(&[fixed_names.clone(), witnesses_with_inverses.clone()]); let unshifted: Vec = flatten(&[fixed_names.clone(), witnesses_with_inverses.clone()]) .into_iter() .filter(|name| !shifted.contains(name)) .collect(); - let all_cols_with_shifts: Vec = - flatten(&[fixed_names.clone(), witnesses_with_inverses.clone(), shifted.clone()]); + let all_cols_with_shifts: Vec = flatten(&[ + fixed_names.clone(), + witnesses_with_inverses.clone(), + shifted.clone(), + ]); ColumnGroups { fixed: fixed_names, From 5ed67b15ca0bf70586358f4fca58fc3e2cf56bc6 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 9 Apr 2024 08:47:01 +0000 Subject: [PATCH 5/6] fix: address todo, cleanup flavor builder --- bberg/src/flavor_builder.rs | 94 ++++++++++------------------------- bberg/src/verifier_builder.rs | 1 - bberg/src/vm_builder.rs | 3 +- 3 files changed, 28 insertions(+), 70 deletions(-) diff --git a/bberg/src/flavor_builder.rs b/bberg/src/flavor_builder.rs index a78250cd39..af972615b8 100644 --- a/bberg/src/flavor_builder.rs +++ b/bberg/src/flavor_builder.rs @@ -1,7 +1,5 @@ use crate::{ file_writer::BBFiles, - lookup_builder::{get_inverses_from_lookups, Lookup}, - permutation_builder::{get_inverses_from_permutations, Permutation}, utils::{get_relations_imports, map_with_newline, snake_case}, }; @@ -11,8 +9,7 @@ pub trait FlavorBuilder { &mut self, name: &str, relation_file_names: &[String], - permutations: &[Permutation], - lookups: &[Lookup], + lookups: &[String], fixed: &[String], witness: &[String], all_cols: &[String], @@ -28,8 +25,7 @@ impl FlavorBuilder for BBFiles { &mut self, name: &str, relation_file_names: &[String], - permutations: &[Permutation], - lookups: &[Lookup], + lookups: &[String], fixed: &[String], witness: &[String], all_cols: &[String], @@ -37,19 +33,8 @@ impl FlavorBuilder for BBFiles { shifted: &[String], all_cols_and_shifts: &[String], ) { - // TODO: move elsewhere and rename - let permutation_inverses = get_inverses_from_permutations(permutations); - let lookup_inverses = get_inverses_from_lookups(lookups); - - // Inverses from both permutations and lookups - let inverses: Vec = permutation_inverses - .iter() - .chain(lookup_inverses.iter()) - .cloned() - .collect(); - let first_poly = &witness[0]; - let includes = flavor_includes(&snake_case(name), relation_file_names, &inverses); + let includes = flavor_includes(&snake_case(name), relation_file_names, &lookups); let num_precomputed = fixed.len(); let num_witness = witness.len(); let num_all = all_cols_and_shifts.len(); @@ -57,7 +42,7 @@ impl FlavorBuilder for BBFiles { // Top of file boilerplate let class_aliases = create_class_aliases(); let relation_definitions = - create_relation_definitions(name, relation_file_names, permutations, lookups); + create_relation_definitions(name, relation_file_names, lookups); let container_size_definitions = container_size_definitions(num_precomputed, num_witness, num_all); @@ -68,7 +53,7 @@ impl FlavorBuilder for BBFiles { create_all_entities(all_cols, to_be_shifted, shifted, all_cols_and_shifts); let proving_and_verification_key = - create_proving_and_verification_key(name, permutations, lookups, to_be_shifted); + create_proving_and_verification_key(name, lookups, to_be_shifted); let polynomial_views = create_polynomial_views(first_poly); let commitment_labels_class = create_commitment_labels(all_cols); @@ -128,8 +113,8 @@ class {name}Flavor {{ } /// Imports located at the top of the flavor files -fn flavor_includes(name: &str, relation_file_names: &[String], permutations: &[String]) -> String { - let relation_imports = get_relations_imports(name, relation_file_names, permutations); +fn flavor_includes(name: &str, relation_file_names: &[String], lookups: &[String]) -> String { + let relation_imports = get_relations_imports(name, relation_file_names, lookups); format!( " @@ -162,21 +147,15 @@ fn create_relations_tuple(master_name: &str, relation_file_names: &[String]) -> } /// Creates comma separated relations tuple file -/// TODO(md): maybe need the filename in here too if we scope these -fn create_permutations_tuple(permutations: &[Permutation]) -> String { - permutations - .iter() - .map(|perm| format!("{}_relation", perm.attribute.clone().unwrap())) - .collect::>() - .join(", ") -} - -fn create_lookups_tuple(lookups: &[Lookup]) -> String { - lookups +fn create_lookups_tuple(lookups: &[String]) -> Option { + if lookups.len() == 0 { + return None; + } + Some(lookups .iter() - .map(|lookup| format!("{}_relation", lookup.attribute.clone().unwrap())) + .map(|lookup| format!("{}_relation", lookup.clone())) .collect::>() - .join(", ") + .join(", ")) } /// Create Class Aliases @@ -210,29 +189,22 @@ fn create_class_aliases() -> &'static str { fn create_relation_definitions( name: &str, relation_file_names: &[String], - permutations: &[Permutation], - lookups: &[Lookup], + lookups: &[String], ) -> String { // Relations tuple = ns::relation_name_0, ns::relation_name_1, ... ns::relation_name_n (comma speratated) let comma_sep_relations = create_relations_tuple(name, relation_file_names); - let comma_sep_perms: String = create_permutations_tuple(permutations); - let comma_sep_lookups: String = create_lookups_tuple(lookups); + let comma_sep_lookups: Option = create_lookups_tuple(lookups); + // We only include the grand product relations if we are given lookups let mut grand_product_relations = String::new(); let mut all_relations = comma_sep_relations.to_string(); - if !permutations.is_empty() { - all_relations = all_relations + &format!(", {comma_sep_perms}"); - grand_product_relations = grand_product_relations + &comma_sep_perms.to_string(); - } - - if !lookups.is_empty() { - all_relations = all_relations + &format!(", {comma_sep_lookups}"); - grand_product_relations = - grand_product_relations.to_owned() + &format!(", {comma_sep_lookups}"); + if let Some(lookups) = comma_sep_lookups{ + all_relations = all_relations + &format!(", {lookups}"); + grand_product_relations = format!("using GrandProductRelations = std::tuple<{lookups}>;"); } format!(" - using GrandProductRelations = std::tuple<{grand_product_relations}>; + {grand_product_relations} using Relations = std::tuple<{all_relations}>; @@ -366,13 +338,12 @@ fn create_all_entities( fn create_proving_and_verification_key( flavor_name: &str, - permutations: &[Permutation], - lookups: &[Lookup], + lookups: &[String], to_be_shifted: &[String], ) -> String { let get_to_be_shifted = return_ref_vector("get_to_be_shifted", to_be_shifted); let compute_logderivative_inverses = - create_compute_logderivative_inverses(flavor_name, permutations, lookups); + create_compute_logderivative_inverses(flavor_name, lookups); format!(" public: @@ -520,26 +491,13 @@ fn create_commitment_labels(all_ents: &[String]) -> String { fn create_compute_logderivative_inverses( flavor_name: &str, - permutations: &[Permutation], - lookups: &[Lookup], + lookups: &[String], ) -> String { - let mut all_perm_and_lookups = Vec::new(); - all_perm_and_lookups.extend( - permutations - .iter() - .map(|perm| perm.attribute.clone().unwrap()), - ); - all_perm_and_lookups.extend( - lookups - .iter() - .map(|lookup| lookup.attribute.clone().unwrap()), - ); - let compute_inverse_transformation = |lookup_name: &String| { format!("bb::compute_logderivative_inverse<{flavor_name}Flavor, {lookup_name}_relation>(prover_polynomials, relation_parameters, this->circuit_size);") }; - let compute_inverses = map_with_newline(&all_perm_and_lookups, compute_inverse_transformation); + let compute_inverses = map_with_newline(&lookups, compute_inverse_transformation); format!( " @@ -661,3 +619,5 @@ fn generate_transcript(witness: &[String]) -> String { }}; ") } + + diff --git a/bberg/src/verifier_builder.rs b/bberg/src/verifier_builder.rs index c648d55052..db789e18cc 100644 --- a/bberg/src/verifier_builder.rs +++ b/bberg/src/verifier_builder.rs @@ -18,7 +18,6 @@ impl VerifierBuilder for BBFiles { "commitments.{n} = transcript->template receive_from_prover(commitment_labels.{n});" ) }; - // TODO: make sure the inverse commitments are not included let wire_commitments = map_with_newline(witness, wire_transformation); let inverse_commitments = map_with_newline(inverses, wire_transformation); diff --git a/bberg/src/vm_builder.rs b/bberg/src/vm_builder.rs index 1bdb9e93e0..ee877a2342 100644 --- a/bberg/src/vm_builder.rs +++ b/bberg/src/vm_builder.rs @@ -116,8 +116,7 @@ pub(crate) fn analyzed_to_cpp( bb_files.create_flavor_hpp( file_name, &relations, - &permutations, // TODO: could be replaced with strings? - &lookups, + &inverses, &fixed, &witness, &all_cols, From 98fe2df1ed4f5398fa1472f59bc8cdf3561e9d3e Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 9 Apr 2024 08:48:16 +0000 Subject: [PATCH 6/6] fmt --- bberg/src/flavor_builder.rs | 30 +++++++++++++----------------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/bberg/src/flavor_builder.rs b/bberg/src/flavor_builder.rs index af972615b8..61c80938a4 100644 --- a/bberg/src/flavor_builder.rs +++ b/bberg/src/flavor_builder.rs @@ -34,15 +34,14 @@ impl FlavorBuilder for BBFiles { all_cols_and_shifts: &[String], ) { let first_poly = &witness[0]; - let includes = flavor_includes(&snake_case(name), relation_file_names, &lookups); + let includes = flavor_includes(&snake_case(name), relation_file_names, lookups); let num_precomputed = fixed.len(); let num_witness = witness.len(); let num_all = all_cols_and_shifts.len(); // Top of file boilerplate let class_aliases = create_class_aliases(); - let relation_definitions = - create_relation_definitions(name, relation_file_names, lookups); + let relation_definitions = create_relation_definitions(name, relation_file_names, lookups); let container_size_definitions = container_size_definitions(num_precomputed, num_witness, num_all); @@ -148,14 +147,16 @@ fn create_relations_tuple(master_name: &str, relation_file_names: &[String]) -> /// Creates comma separated relations tuple file fn create_lookups_tuple(lookups: &[String]) -> Option { - if lookups.len() == 0 { + if lookups.is_empty() { return None; } - Some(lookups - .iter() - .map(|lookup| format!("{}_relation", lookup.clone())) - .collect::>() - .join(", ")) + Some( + lookups + .iter() + .map(|lookup| format!("{}_relation", lookup.clone())) + .collect::>() + .join(", "), + ) } /// Create Class Aliases @@ -198,7 +199,7 @@ fn create_relation_definitions( // We only include the grand product relations if we are given lookups let mut grand_product_relations = String::new(); let mut all_relations = comma_sep_relations.to_string(); - if let Some(lookups) = comma_sep_lookups{ + if let Some(lookups) = comma_sep_lookups { all_relations = all_relations + &format!(", {lookups}"); grand_product_relations = format!("using GrandProductRelations = std::tuple<{lookups}>;"); } @@ -489,15 +490,12 @@ fn create_commitment_labels(all_ents: &[String]) -> String { ) } -fn create_compute_logderivative_inverses( - flavor_name: &str, - lookups: &[String], -) -> String { +fn create_compute_logderivative_inverses(flavor_name: &str, lookups: &[String]) -> String { let compute_inverse_transformation = |lookup_name: &String| { format!("bb::compute_logderivative_inverse<{flavor_name}Flavor, {lookup_name}_relation>(prover_polynomials, relation_parameters, this->circuit_size);") }; - let compute_inverses = map_with_newline(&lookups, compute_inverse_transformation); + let compute_inverses = map_with_newline(lookups, compute_inverse_transformation); format!( " @@ -619,5 +617,3 @@ fn generate_transcript(witness: &[String]) -> String { }}; ") } - -