feat(avm): skippable check-circuit

Author: fcarreiro

barretenberg/cpp/src/barretenberg/vm2/avm_api.cpp

@@ -45,15 +45,15 @@ bool AvmAPI::check_circuit(const AvmAPI::ProvingInputs& inputs)
     info("Generating trace...");
     AvmTraceGenHelper tracegen_helper;
     tracegen::TraceContainer trace;
-    tracegen_helper.fill_trace_columns(trace, std::move(events), inputs.publicInputs);
+    AVM_TRACK_TIME("tracegen/all", tracegen_helper.fill_trace_columns(trace, std::move(events), inputs.publicInputs));
 
     // Go into interactive debug mode if requested.
     if (getenv("AVM_DEBUG") != nullptr) {
         InteractiveDebugger debugger(trace);
         debugger.run();
     }
 
-    tracegen_helper.fill_trace_interactions(trace);
+    AVM_TRACK_TIME("tracegen/all", tracegen_helper.fill_trace_interactions(trace));
 
     // Check circuit.
     info("Checking circuit...");

barretenberg/cpp/src/barretenberg/vm2/constraining/check_circuit.cpp

@@ -10,11 +10,12 @@
 #include "barretenberg/common/thread.hpp"
 #include "barretenberg/honk/proof_system/logderivative_library.hpp"
 #include "barretenberg/relations/relation_parameters.hpp"
+#include "barretenberg/vm2/constraining/testing/check_relation.hpp"
 #include "barretenberg/vm2/generated/columns.hpp"
 
 namespace bb::avm2::constraining {
 
-void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows)
+void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows, bool skippable_enabled)
 {
     bb::RelationParameters<AvmFlavor::FF> params = {
         .eta = 0,
@@ -37,9 +38,18 @@ void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows)
             typename Relation::SumcheckArrayOfValuesOverSubrelations result{};
 
             for (size_t r = 0; r < num_rows; ++r) {
-                Relation::accumulate(result, polys.get_row(r), {}, 1);
+                auto row = polys.get_row(r);
+                if constexpr (isSkippable<Relation, decltype(row)>) {
+                    if (skippable_enabled && Relation::skip(row)) {
+                        continue;
+                    }
+                }
+
+                Relation::accumulate(result, row, {}, 1);
+
+                // Check the linearly independent part of the relation.
                 for (size_t j = 0; j < result.size(); ++j) {
-                    if (!result[j].is_zero()) {
+                    if (detail::subrelation_is_linearly_independent<Relation>(j) && !result[j].is_zero()) {
                         throw std::runtime_error(format("Relation ",
                                                         Relation::NAME,
                                                         ", subrelation ",
@@ -49,6 +59,13 @@ void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows)
                     }
                 }
             }
+            // Do final check for the linearly dependent part of the relation.
+            for (size_t j = 0; j < result.size(); ++j) {
+                if (!result[j].is_zero()) {
+                    throw std::runtime_error(format(
+                        "Relation ", Relation::NAME, ", subrelation ", Relation::get_subrelation_label(j), " failed."));
+                }
+            }
         });
     });
 
@@ -62,8 +79,29 @@ void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows)
             // Check the logderivative relation
             typename Relation::SumcheckArrayOfValuesOverSubrelations lookup_result{};
             for (size_t r = 0; r < num_rows; ++r) {
-                Relation::accumulate(lookup_result, polys.get_row(r), params, 1);
+                auto row = polys.get_row(r);
+                if constexpr (isSkippable<Relation, decltype(row)>) {
+                    if (skippable_enabled && Relation::skip(row)) {
+                        continue;
+                    }
+                }
+
+                Relation::accumulate(lookup_result, row, params, 1);
+
+                for (size_t subrelation_idx = 0; subrelation_idx < lookup_result.size(); ++subrelation_idx) {
+                    // We need to check the linearly independent part of the relation.
+                    if (detail::subrelation_is_linearly_independent<Relation>(subrelation_idx) &&
+                        !lookup_result[subrelation_idx].is_zero()) {
+                        throw std::runtime_error(format("Lookup ",
+                                                        Relation::NAME,
+                                                        ", subrelation ",
+                                                        Relation::get_subrelation_label(subrelation_idx),
+                                                        " failed at row ",
+                                                        r));
+                    }
+                }
             }
+            // Do final check for the linearly dependent part of the relation.
             for (auto r : lookup_result) {
                 if (!r.is_zero()) {
                     throw std::runtime_error(format("Lookup ", Relation::NAME, " failed."));

barretenberg/cpp/src/barretenberg/vm2/constraining/check_circuit.hpp

@@ -8,6 +8,6 @@ namespace bb::avm2::constraining {
 
 // This is a version of check circuit that runs on the prover polynomials.
 // It is the closest to "real proving" that we can get without actually running the prover.
-void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows);
+void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows, bool skippable_enabled = true);
 
 } // namespace bb::avm2::constraining

barretenberg/cpp/src/barretenberg/vm2/proving_helper.cpp

@@ -89,12 +89,18 @@ bool AvmProvingHelper::check_circuit(tracegen::TraceContainer&& trace)
     // PLUS one extra row to catch any possible errors in the empty remainder
     // of the circuit.
     const size_t num_rows = trace.get_num_rows_without_clk() + 1;
-    info("Running check circuit over ", num_rows, " rows.");
+    const bool skippable_enabled = true;
+    info("Running check ",
+         skippable_enabled ? "(with skippable)" : "(without skippable)",
+         " circuit over ",
+         num_rows,
+         " rows.");
 
     // Warning: this destroys the trace.
     auto polynomials = AVM_TRACK_TIME_V("proving/prove:compute_polynomials", constraining::compute_polynomials(trace));
     try {
-        AVM_TRACK_TIME("proving/check_circuit", constraining::run_check_circuit(polynomials, num_rows));
+        AVM_TRACK_TIME("proving/check_circuit",
+                       constraining::run_check_circuit(polynomials, num_rows, skippable_enabled));
     } catch (std::runtime_error& e) {
         // FIXME: This exception is never caught because it's thrown in a different thread.
         // Execution never gets here!