chore: move check_circuit functionality from TranslatorCircuitBuilder into a TranslatorCircuitChecker

barretenberg/cpp/src/barretenberg/circuit_checker/mega_circuit_builder.test.cpp

@@ -13,21 +13,20 @@ namespace bb {
 
 TEST(MegaCircuitBuilder, CopyConstructor)
 {
-    MegaCircuitBuilder circuit_constructor = MegaCircuitBuilder();
+    MegaCircuitBuilder builder = MegaCircuitBuilder();
     fr a = fr::one();
-    circuit_constructor.add_public_variable(a);
+    builder.add_public_variable(a);
 
     for (size_t i = 0; i < 16; ++i) {
         for (size_t j = 0; j < 16; ++j) {
             uint64_t left = static_cast<uint64_t>(j);
             uint64_t right = static_cast<uint64_t>(i);
-            uint32_t left_idx = circuit_constructor.add_variable(fr(left));
-            uint32_t right_idx = circuit_constructor.add_variable(fr(right));
-            uint32_t result_idx = circuit_constructor.add_variable(fr(left ^ right));
+            uint32_t left_idx = builder.add_variable(fr(left));
+            uint32_t right_idx = builder.add_variable(fr(right));
+            uint32_t result_idx = builder.add_variable(fr(left ^ right));
 
-            uint32_t add_idx =
-                circuit_constructor.add_variable(fr(left) + fr(right) + circuit_constructor.get_variable(result_idx));
-            circuit_constructor.create_big_add_gate(
+            uint32_t add_idx = builder.add_variable(fr(left) + fr(right) + builder.get_variable(result_idx));
+            builder.create_big_add_gate(
                 { left_idx, right_idx, result_idx, add_idx, fr(1), fr(1), fr(1), fr(-1), fr(0) });
         }
     }
@@ -38,25 +37,25 @@ TEST(MegaCircuitBuilder, CopyConstructor)
     auto z = fr::random_element();
 
     // Add gates corresponding to the above operations
-    circuit_constructor.queue_ecc_add_accum(P1);
-    circuit_constructor.queue_ecc_mul_accum(P2, z);
-    circuit_constructor.queue_ecc_eq();
+    builder.queue_ecc_add_accum(P1);
+    builder.queue_ecc_mul_accum(P2, z);
+    builder.queue_ecc_eq();
 
-    bool result = CircuitChecker::check(circuit_constructor);
+    bool result = CircuitChecker::check(builder);
     EXPECT_EQ(result, true);
 
-    MegaCircuitBuilder duplicate_circuit_constructor{ circuit_constructor };
+    MegaCircuitBuilder duplicate_builder{ builder };
 
-    EXPECT_EQ(duplicate_circuit_constructor, circuit_constructor);
-    EXPECT_TRUE(CircuitChecker::check(duplicate_circuit_constructor));
+    EXPECT_EQ(duplicate_builder, builder);
+    EXPECT_TRUE(CircuitChecker::check(duplicate_builder));
 }
 
 TEST(MegaCircuitBuilder, BaseCase)
 {
-    MegaCircuitBuilder circuit_constructor = MegaCircuitBuilder();
+    MegaCircuitBuilder builder = MegaCircuitBuilder();
     fr a = fr::one();
-    circuit_constructor.add_public_variable(a);
-    bool result = CircuitChecker::check(circuit_constructor);
+    builder.add_public_variable(a);
+    bool result = CircuitChecker::check(builder);
     EXPECT_EQ(result, true);
 }
 

barretenberg/cpp/src/barretenberg/circuit_checker/translator_circuit_checker.hpp

@@ -0,0 +1,59 @@
+#pragma once
+#include "barretenberg/translator_vm/translator_circuit_builder.hpp"
+namespace bb {
+class TranslatorCircuitChecker {
+    using Fr = bb::fr;
+    using Fq = bb::fq;
+    using Builder = TranslatorCircuitBuilder;
+    using WireIds = Builder::WireIds;
+
+    // Number of limbs used to decompose a 254-bit value for modular arithmetic
+    static constexpr size_t NUM_BINARY_LIMBS = Builder::NUM_BINARY_LIMBS;
+
+  public:
+    struct RelationInputs {
+        std::array<Fr, NUM_BINARY_LIMBS> x_limbs;
+        std::array<Fr, NUM_BINARY_LIMBS> v_limbs;
+        std::array<Fr, NUM_BINARY_LIMBS> v_squared_limbs = { 0 };
+        std::array<Fr, NUM_BINARY_LIMBS> v_cubed_limbs = { 0 };
+        std::array<Fr, NUM_BINARY_LIMBS> v_quarted_limbs = { 0 };
+    };
+    TranslatorCircuitChecker() = default;
+
+    /**
+     * @brief Get the result of accumulation, stored as 4 binary limbs in the first row of the circuit.
+     *
+     */
+    static Fq get_computation_result(const Builder& circuit)
+    {
+        const size_t RESULT_ROW = 1;
+        ASSERT(circuit.num_gates > RESULT_ROW);
+        return Fq(
+            circuit.get_variable(circuit.wires[WireIds::ACCUMULATORS_BINARY_LIMBS_0][RESULT_ROW]) +
+            circuit.get_variable(circuit.wires[WireIds::ACCUMULATORS_BINARY_LIMBS_1][RESULT_ROW]) * Builder::SHIFT_1 +
+            circuit.get_variable(circuit.wires[WireIds::ACCUMULATORS_BINARY_LIMBS_2][RESULT_ROW]) * Builder::SHIFT_2 +
+            circuit.get_variable(circuit.wires[WireIds::ACCUMULATORS_BINARY_LIMBS_3][RESULT_ROW]) * Builder::SHIFT_3);
+    }
+
+    /**
+     * @brief Create limb representations of x and powers of v that are needed to compute the witness or check
+     * circuit correctness
+     *
+     * @param evaluation_input_x The point at which the polynomials are being evaluated
+     * @param batching_challenge_v The batching challenge
+     * @return RelationInputs
+     */
+    static RelationInputs compute_relation_inputs_limbs(const Fq& batching_challenge_v, const Fq& evaluation_input_x);
+
+    /**
+     * @brief Check the witness satisifies the circuit
+     *
+     * @details Goes through each gate and checks the correctness of accumulation
+     *
+     * @return true
+     * @return false
+     */
+
+    static bool check(const Builder& circuit);
+};
+} // namespace bb