feat: Goblin Translator (final part)

barretenberg/.vscode/settings.json

@@ -116,7 +116,7 @@
   "typescript.enablePromptUseWorkspaceTsdk": true,
   "[cpp]": {
     // doesn't conflict with barratenberg.code-workspace settings.
-    "editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd"
+    "editor.defaultFormatter": "xaver.clang-format"
   },
   "[terraform]": {
     "editor.defaultFormatter": "hashicorp.terraform"
@@ -127,5 +127,6 @@
   "[javascript]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode"
   },
-  "cmake.sourceDirectory": "${workspaceFolder}/cpp"
+  "cmake.sourceDirectory": "${workspaceFolder}/cpp",
+  "clangd.path": "/usr/bin/clangd-16"
 }

barretenberg/barretenberg.code-workspace

@@ -83,7 +83,7 @@
         // Clangd. Note that this setting may be overridden by  user settings
         // to the default value "clangd".
         //
-        "clangd.path": "clangd-16",
+        "clangd.path": "/usr/bin/clangd-16",
         // We should disable automatic inclusion of headers unless we decide to follow "WhyIWYU".
         "clangd.arguments": [
             "-header-insertion=never"

barretenberg/cpp/CMakePresets.json

@@ -21,6 +21,19 @@
         "TARGET_ARCH": "skylake"
       }
     },
+    {
+      "name": "default-dbg",
+      "displayName": "Debugging build with Clang",
+      "description": "Build with globally installed Clang in debug mode",
+      "inherits": "default",
+      "environment": {
+        "CMAKE_BUILD_TYPE": "Debug"
+      },
+      "cacheVariables": {
+        "ENABLE_ASAN": "OFF",
+        "DISABLE_ASM": "ON"
+      }
+    },
     {
       "name": "homebrew",
       "displayName": "Homebrew + Clang",
@@ -250,6 +263,11 @@
       "inheritConfigureEnvironment": true,
       "jobs": 0
     },
+    {
+      "name": "default-dbg",
+      "inherits": "default",
+      "configurePreset": "default-dbg"
+    },
     {
       "name": "homebrew",
       "inherits": "default",
@@ -360,6 +378,11 @@
       "configurePreset": "default",
       "inheritConfigureEnvironment": true
     },
+    {
+      "name": "default-dbg",
+      "inherits": "default",
+      "configurePreset": "default-dbg"
+    },
     {
       "name": "homebrew",
       "inherits": "default",

barretenberg/cpp/src/CMakeLists.txt

@@ -74,6 +74,7 @@ add_subdirectory(barretenberg/srs)
 add_subdirectory(barretenberg/stdlib)
 add_subdirectory(barretenberg/sumcheck)
 add_subdirectory(barretenberg/transcript)
+add_subdirectory(barretenberg/translator_vm)
 add_subdirectory(barretenberg/ultra_honk)
 add_subdirectory(barretenberg/wasi)
 

barretenberg/cpp/src/barretenberg/benchmark/CMakeLists.txt

@@ -2,4 +2,5 @@ add_subdirectory(decrypt_bench)
 add_subdirectory(pippenger_bench)
 add_subdirectory(plonk_bench)
 add_subdirectory(honk_bench)
-add_subdirectory(relations_bench)
+add_subdirectory(relations_bench)
+add_subdirectory(widgets_bench)

barretenberg/cpp/src/barretenberg/benchmark/relations_bench/CMakeLists.txt

@@ -2,16 +2,13 @@
 set(BENCHMARK_SOURCES
   barycentric.bench.cpp
   relations.bench.cpp
-  widget.bench.cpp
 )
 
 # Required libraries for benchmark suites
 set(LINKED_LIBRARIES
-  polynomials
   proof_system
   benchmark::benchmark
   transcript
-  stdlib_primitives
 )
 
 # Add executable and custom target for each suite, e.g. ultra_honk_bench

barretenberg/cpp/src/barretenberg/benchmark/relations_bench/relations.bench.cpp

@@ -1,29 +1,26 @@
+#include "barretenberg/flavor/ecc_vm.hpp"
+#include "barretenberg/flavor/goblin_translator.hpp"
 #include "barretenberg/flavor/goblin_ultra.hpp"
 #include "barretenberg/flavor/ultra.hpp"
-#include "barretenberg/relations/auxiliary_relation.hpp"
-#include "barretenberg/relations/ecc_op_queue_relation.hpp"
-#include "barretenberg/relations/elliptic_relation.hpp"
-#include "barretenberg/relations/gen_perm_sort_relation.hpp"
-#include "barretenberg/relations/lookup_relation.hpp"
-#include "barretenberg/relations/permutation_relation.hpp"
-#include "barretenberg/relations/relation_parameters.hpp"
-#include "barretenberg/relations/ultra_arithmetic_relation.hpp"
 #include <benchmark/benchmark.h>
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
+using namespace proof_system::honk::sumcheck; // WORKTODO
+
 namespace proof_system::benchmark::relations {
 
-using FF = barretenberg::fr;
+using Fr = barretenberg::fr;
+using Fq = grumpkin::fr;
 
 template <typename Flavor, typename Relation> void execute_relation(::benchmark::State& state)
 {
     using AllValues = typename Flavor::AllValues;
     using SumcheckArrayOfValuesOverSubrelations = typename Relation::SumcheckArrayOfValuesOverSubrelations;
 
-    auto params = proof_system::RelationParameters<FF>::get_random();
+    auto params = proof_system::RelationParameters<Fr>::get_random();
 
     // Extract an array containing all the polynomial evaluations at a given row i
     AllValues new_value;
@@ -36,46 +33,118 @@ template <typename Flavor, typename Relation> void execute_relation(::benchmark:
     }
 }
 
-void auxiliary_relation(::benchmark::State& state) noexcept
+void ultra_auxiliary_relation(::benchmark::State& state) noexcept
 {
-    execute_relation<honk::flavor::Ultra, AuxiliaryRelation<FF>>(state);
+    execute_relation<honk::flavor::Ultra, AuxiliaryRelation<Fr>>(state);
 }
-BENCHMARK(auxiliary_relation);
+BENCHMARK(ultra_auxiliary_relation);
 
-void elliptic_relation(::benchmark::State& state) noexcept
+void ultra_elliptic_relation(::benchmark::State& state) noexcept
 {
-    execute_relation<honk::flavor::Ultra, EllipticRelation<FF>>(state);
+    execute_relation<honk::flavor::Ultra, EllipticRelation<Fr>>(state);
 }
-BENCHMARK(elliptic_relation);
+BENCHMARK(ultra_elliptic_relation);
 
-void ecc_op_queue_relation(::benchmark::State& state) noexcept
+void ultra_ecc_op_queue_relation(::benchmark::State& state) noexcept
 {
-    execute_relation<honk::flavor::GoblinUltra, EccOpQueueRelation<FF>>(state);
+    execute_relation<honk::flavor::GoblinUltra, EccOpQueueRelation<Fr>>(state);
 }
-BENCHMARK(ecc_op_queue_relation);
+BENCHMARK(ultra_ecc_op_queue_relation);
 
-void gen_perm_sort_relation(::benchmark::State& state) noexcept
+void ultra_gen_perm_sort_relation(::benchmark::State& state) noexcept
 {
-    execute_relation<honk::flavor::Ultra, GenPermSortRelation<FF>>(state);
+    execute_relation<honk::flavor::Ultra, GenPermSortRelation<Fr>>(state);
 }
-BENCHMARK(gen_perm_sort_relation);
+BENCHMARK(ultra_gen_perm_sort_relation);
 
-void lookup_relation(::benchmark::State& state) noexcept
+void ultralookup_relation(::benchmark::State& state) noexcept
 {
-    execute_relation<honk::flavor::Ultra, LookupRelation<FF>>(state);
+    execute_relation<honk::flavor::Ultra, LookupRelation<Fr>>(state);
 }
-BENCHMARK(lookup_relation);
+BENCHMARK(ultralookup_relation);
 
 void ultra_permutation_relation(::benchmark::State& state) noexcept
 {
-    execute_relation<honk::flavor::Ultra, UltraPermutationRelation<FF>>(state);
+    execute_relation<honk::flavor::Ultra, UltraPermutationRelation<Fr>>(state);
 }
 BENCHMARK(ultra_permutation_relation);
 
 void ultra_arithmetic_relation(::benchmark::State& state) noexcept
 {
-    execute_relation<honk::flavor::Ultra, UltraArithmeticRelation<FF>>(state);
+    execute_relation<honk::flavor::Ultra, UltraArithmeticRelation<Fr>>(state);
 }
 BENCHMARK(ultra_arithmetic_relation);
 
+void translator_decomposition_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::GoblinTranslator, GoblinTranslatorDecompositionRelation<Fr>>(state);
+}
+BENCHMARK(translator_decomposition_relation);
+
+void translator_opcode_constraint_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::GoblinTranslator, GoblinTranslatorOpcodeConstraintRelation<Fr>>(state);
+}
+BENCHMARK(translator_opcode_constraint_relation);
+
+void translator_accumulator_transfer_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::GoblinTranslator, GoblinTranslatorAccumulatorTransferRelation<Fr>>(state);
+}
+BENCHMARK(translator_accumulator_transfer_relation);
+
+void translator_gen_perm_sort_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::GoblinTranslator, GoblinTranslatorGenPermSortRelation<Fr>>(state);
+}
+BENCHMARK(translator_gen_perm_sort_relation);
+
+void translator_non_native_field_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::GoblinTranslator, GoblinTranslatorNonNativeFieldRelation<Fr>>(state);
+}
+BENCHMARK(translator_non_native_field_relation);
+
+void translator_permutation_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::GoblinTranslator, GoblinTranslatorPermutationRelation<Fr>>(state);
+}
+BENCHMARK(translator_permutation_relation);
+
+// void eccvm_lookup_relation(::benchmark::State& state) noexcept
+// {
+//     execute_relation<honk::flavor::ECCVM, ECCVMLookupRelation<Fq>>(state);
+// }
+// BENCHMARK(eccvm_lookup_relation);
+
+// void eccvm_msm_relation(::benchmark::State& state) noexcept
+// {
+//     execute_relation<honk::flavor::ECCVM, ECCVMMSMRelation<Fq>>(state);
+// }
+// BENCHMARK(eccvm_msm_relation);
+
+// void eccvm_point_table_relation(::benchmark::State& state) noexcept
+// {
+//     execute_relation<honk::flavor::ECCVM, ECCVMPointTableRelation<Fq>>(state);
+// }
+// BENCHMARK(eccvm_point_table_relation);
+
+// void eccvm_set_relation(::benchmark::State& state) noexcept
+// {
+//     execute_relation<honk::flavor::ECCVM, ECCVMSetRelation<Fq>>(state);
+// }
+// BENCHMARK(eccvm_set_relation);
+
+// void eccvm_transcript_relation(::benchmark::State& state) noexcept
+// {
+//     execute_relation<honk::flavor::ECCVM, ECCVMTranscriptRelation<Fq>>(state);
+// }
+// BENCHMARK(eccvm_transcript_relation);
+
+// void eccvm_wnaf_relation(::benchmark::State& state) noexcept
+// {
+//     execute_relation<honk::flavor::ECCVM, ECCVMWnafRelation<Fq>>(state);
+// }
+// BENCHMARK(eccvm_wnaf_relation);
+
 } // namespace proof_system::benchmark::relations

barretenberg/cpp/src/barretenberg/benchmark/widgets_bench/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Each source represents a separate benchmark suite 
+set(BENCHMARK_SOURCES
+  widget.bench.cpp
+)
+
+# Required libraries for benchmark suites
+set(LINKED_LIBRARIES
+  polynomials
+  proof_system
+  benchmark::benchmark
+  transcript
+  stdlib_primitives
+)
+
+# Add executable and custom target for each suite, e.g. ultra_honk_bench
+foreach(BENCHMARK_SOURCE ${BENCHMARK_SOURCES})
+  get_filename_component(BENCHMARK_NAME ${BENCHMARK_SOURCE} NAME_WE) # extract name without extension
+  add_executable(${BENCHMARK_NAME}_bench main.bench.cpp ${BENCHMARK_SOURCE})
+  target_link_libraries(${BENCHMARK_NAME}_bench ${LINKED_LIBRARIES})
+  add_custom_target(run_${BENCHMARK_NAME} COMMAND ${BENCHMARK_NAME} WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+endforeach()

barretenberg/cpp/src/barretenberg/benchmark/widgets_bench/main.bench.cpp

@@ -0,0 +1,3 @@
+#include <benchmark/benchmark.h>
+
+BENCHMARK_MAIN();

barretenberg/cpp/src/barretenberg/commitment_schemes/ipa/ipa.hpp

@@ -37,7 +37,11 @@ template <typename Curve> class IPA {
                                       const Polynomial& polynomial,
                                       BaseTranscript<Fr>& transcript)
     {
-        ASSERT(opening_pair.challenge != 0 && "The challenge point should not be zero");
+        info("IPA challenge: ", opening_pair.challenge);
+        info("IPA eval     : ", opening_pair.evaluation);
+        info("IPA comm     : ", ck->commit(polynomial));
+
+        ASSERT(opening_pair.challenge != 0 && "The challenge point should not be zero"); // why?
         auto poly_degree = static_cast<size_t>(polynomial.size());
         transcript.send_to_verifier("IPA:poly_degree", static_cast<uint64_t>(poly_degree));
         Fr generator_challenge = transcript.get_challenge("IPA:generator_challenge");
@@ -136,6 +140,10 @@ template <typename Curve> class IPA {
      */
     static bool verify(std::shared_ptr<VK> vk, const OpeningClaim<Curve>& opening_claim, BaseTranscript<Fr>& transcript)
     {
+        info("IPA challenge: ", opening_claim.opening_pair.challenge);
+        info("IPA eval     : ", opening_claim.opening_pair.evaluation);
+        info("IPA comm     : ", opening_claim.commitment);
+
         auto poly_degree = static_cast<size_t>(transcript.template receive_from_prover<uint64_t>("IPA:poly_degree"));
         Fr generator_challenge = transcript.get_challenge("IPA:generator_challenge");
         auto aux_generator = Commitment::one() * generator_challenge;
@@ -202,7 +210,7 @@ template <typename Curve> class IPA {
         // Copy the G_vector to local memory.
         std::vector<Commitment> G_vec_local(poly_degree);
         // The SRS stored in the commitment key is the result after applying the pippenger point table so the
-        // values at odd indices contain the point {srs[i-1].x * beta, srs[i-1].y}, where beta is the endomorphism
+        // values at odd indices contain the point {srs[i-1].x * g beta, srs[i-1].y}, where beta is the endomorphism
         // G_vec_local should use only the original SRS thus we extract only the even indices.
         for (size_t i = 0; i < poly_degree * 2; i += 2) {
             G_vec_local[i >> 1] = srs_elements[i];
@@ -215,6 +223,8 @@ template <typename Curve> class IPA {
 
         GroupElement right_hand_side = G_zero * a_zero + aux_generator * a_zero * b_zero;
 
+        info(C_zero.normalize());
+        info(right_hand_side.normalize());
         return (C_zero.normalize() == right_hand_side.normalize());
     }
 };

barretenberg/cpp/src/barretenberg/commitment_schemes/shplonk/shplonk.hpp

@@ -104,6 +104,7 @@ template <typename Curve> class ShplonkProver_ {
         const Fr& nu_challenge,
         const Fr& z_challenge)
     {
+
         const size_t num_opening_pairs = opening_pairs.size();
 
         // {ẑⱼ(r)}ⱼ , where ẑⱼ(r) = 1/zⱼ(r) = 1/(r - xⱼ)
@@ -163,16 +164,16 @@ template <typename Curve> class ShplonkVerifier_ {
      */
     static OpeningClaim<Curve> reduce_verification(std::shared_ptr<VK> vk,
                                                    std::span<const OpeningClaim<Curve>> claims,
-                                                   auto& transcript)
+                                                   auto& transcript,
+                                                   const std::string& suffix = "")
     {
 
         const size_t num_claims = claims.size();
 
-        const Fr nu = transcript.get_challenge("Shplonk:nu");
-
-        auto Q_commitment = transcript.template receive_from_prover<Commitment>("Shplonk:Q");
+        const Fr nu = transcript.get_challenge("Shplonk" + suffix + ":nu");
+        auto Q_commitment = transcript.template receive_from_prover<Commitment>("Shplonk" + suffix + ":Q");
 
-        const Fr z_challenge = transcript.get_challenge("Shplonk:z");
+        const Fr z_challenge = transcript.get_challenge("Shplonk" + suffix + ":z");
 
         // [G] = [Q] - ∑ⱼ ρʲ / ( r − xⱼ )⋅[fⱼ] + G₀⋅[1]
         //     = [Q] - [∑ⱼ ρʲ ⋅ ( fⱼ(X) − vⱼ) / ( r − xⱼ )]